@acorex/platform 20.7.8 → 20.7.10

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;
     }
@@ -1346,42 +1353,24 @@ function sortMergedSections(mainSections, extraSections, mainSectionIds) {
             return entityOrderDiff;
         return (a.order ?? 0) - (b.order ?? 0);
     });
-    // Build index map for main sections to preserve original order when no explicit order is specified
-    const mainSectionIndexMap = new Map();
-    mainSections.forEach((s, idx) => mainSectionIndexMap.set(s.id, idx));
     // Middle block: main sections + middle-only sections
-    // Sort by explicit order if present, otherwise use original array index for main sections
-    // Extra middle sections without order go after main sections
-    const middleBlock = [...mainSections, ...middleSections].sort((a, b) => {
-        const aHasOrder = a.order !== undefined;
-        const bHasOrder = b.order !== undefined;
-        // If both have explicit order, sort by order
-        if (aHasOrder && bHasOrder) {
-            return a.order - b.order;
-        }
-        // If neither has order, preserve original array position for main sections
-        if (!aHasOrder && !bHasOrder) {
-            const aIdx = mainSectionIndexMap.get(a.id) ?? Infinity;
-            const bIdx = mainSectionIndexMap.get(b.id) ?? Infinity;
-            return aIdx - bIdx;
-        }
-        // If only one has order, the one with order comes first (explicit ordering takes precedence)
-        if (aHasOrder)
-            return -1;
-        return 1;
+    // Sort by order (undefined order is treated as 0)
+    const middleBlock = [...mainSections, ...middleSections];
+    const sortedMiddleBlock = middleBlock.sort((a, b) => {
+        // Treat undefined order as 0 for sorting
+        const aOrder = a.order ?? 0;
+        const bOrder = b.order ?? 0;
+        return aOrder - bOrder;
     });
-    return [...beforeSections, ...middleBlock, ...afterSections];
+    return [...beforeSections, ...sortedMiddleBlock, ...afterSections];
 }
 
 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 +1393,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' }); }
@@ -2071,7 +2043,7 @@ class AXPEntityDetailPopoverComponent {
         return importantProperties;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityDetailPopoverComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.16", type: AXPEntityDetailPopoverComponent, isStandalone: true, selector: "axp-entity-detail-popover", inputs: { entity: { classPropertyName: "entity", publicName: "entity", isSignal: true, isRequired: true, transformFunction: null }, entityId: { classPropertyName: "entityId", publicName: "entityId", isSignal: true, isRequired: true, transformFunction: null }, textField: { classPropertyName: "textField", publicName: "textField", isSignal: true, isRequired: false, transformFunction: null }, valueField: { classPropertyName: "valueField", publicName: "valueField", isSignal: true, isRequired: false, transformFunction: null }, item: { classPropertyName: "item", publicName: "item", isSignal: true, isRequired: false, transformFunction: null }, breadcrumb: { classPropertyName: "breadcrumb", publicName: "breadcrumb", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "detailPopover", first: true, predicate: ["detailPopover"], descendants: true, isSignal: true }], ngImport: i0, template: "<ax-popover [openOn]=\"'manual'\" #detailPopover (openChange)=\"onDetailPopoverOpenChange($event)\">\n  <div class=\"ax-lightest-surface ax-border ax-rounded-lg ax-shadow-lg ax-p-4 ax-min-w-[400px]\">\n    <div class=\"ax-mb-4 ax-border-b ax-pb-2\">\n      <h3 class=\"ax-text-base ax-font-semibold ax-text-on-lightest-surface\">\n        @if (entityDetails()?.entityData?.[textField()]) {\n          {{ entityDetails()?.entityData[textField()] }}\n        } @else {\n          {{ item()?.[textField()] }}\n        }\n      </h3>\n      @if (breadcrumb()) {\n        <div class=\"ax-text-xs ax-text-neutral-500 ax-mt-1\">{{ breadcrumb() }}</div>\n      }\n    </div>\n    @if (isLoadingDetails()) {\n      <div class=\"ax-flex ax-items-center ax-justify-center ax-py-8\">\n        <ax-loading>Loading details...</ax-loading>\n      </div>\n    } @else if (entityDetails()) {\n      <div class=\"ax-space-y-3 ax-mb-4\">\n        <!-- Important Entity Data -->\n        @if (entityDetails()?.entityData) {\n          <axp-widgets-container [context]=\"entityDetails()?.entityData\">\n            <div class=\"ax-space-y-2\">\n              @for (item of getEntityPropertiesWithWidgets(); track item.name) {\n                <div class=\"ax-flex ax-justify-between ax-items-center\">\n                  <span class=\"ax-text-sm ax-font-medium\">{{ item.title | translate | async }}:</span>\n                  <div class=\"ax-flex-1 ax-ml-2 ax-max-w-48\">\n                    <ng-container axp-widget-renderer [node]=\"item.node\" [mode]=\"'view'\"></ng-container>\n                  </div>\n                </div>\n              }\n            </div>\n          </axp-widgets-container>\n        }\n      </div>\n      <div class=\"ax-flex ax-gap-2 ax-justify-end ax-sm\">\n        <ax-button [color]=\"'primary'\" [look]=\"'solid'\" text=\"Open Details\" (click)=\"navigateToDetails()\"> </ax-button>\n      </div>\n    }\n  </div>\n</ax-popover>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i3.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: "ngmodule", type: AXPopoverModule }, { kind: "component", type: i2.AXPopoverComponent, selector: "ax-popover", inputs: ["width", "disabled", "offsetX", "offsetY", "target", "placement", "content", "openOn", "closeOn", "hasBackdrop", "openAfter", "closeAfter", "repositionOnScroll", "backdropClass", "panelClass", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: i3$1.AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: ["context", "functions"], outputs: ["onContextChanged"] }, { kind: "directive", type: i3$1.AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged", "onLoad"], exportAs: ["widgetRenderer"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "ngmodule", type: AXLoadingModule }, { kind: "component", type: i4.AXLoadingComponent, selector: "ax-loading", inputs: ["visible", "type", "context"], outputs: ["visibleChange"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.16", type: AXPEntityDetailPopoverComponent, isStandalone: true, selector: "axp-entity-detail-popover", inputs: { entity: { classPropertyName: "entity", publicName: "entity", isSignal: true, isRequired: true, transformFunction: null }, entityId: { classPropertyName: "entityId", publicName: "entityId", isSignal: true, isRequired: true, transformFunction: null }, textField: { classPropertyName: "textField", publicName: "textField", isSignal: true, isRequired: false, transformFunction: null }, valueField: { classPropertyName: "valueField", publicName: "valueField", isSignal: true, isRequired: false, transformFunction: null }, item: { classPropertyName: "item", publicName: "item", isSignal: true, isRequired: false, transformFunction: null }, breadcrumb: { classPropertyName: "breadcrumb", publicName: "breadcrumb", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "detailPopover", first: true, predicate: ["detailPopover"], descendants: true, isSignal: true }], ngImport: i0, template: "<ax-popover [openOn]=\"'manual'\" #detailPopover (openChange)=\"onDetailPopoverOpenChange($event)\">\n  <div class=\"ax-lightest-surface ax-border ax-rounded-lg ax-shadow-lg ax-p-4 ax-min-w-[400px]\">\n    <div class=\"ax-mb-4 ax-border-b ax-pb-2\">\n      <h3 class=\"ax-text-base ax-font-semibold ax-text-on-lightest-surface\">\n        @if (entityDetails()?.entityData?.[textField()]) {\n          {{ entityDetails()?.entityData[textField()] }}\n        } @else {\n          {{ item()?.[textField()] }}\n        }\n      </h3>\n      @if (breadcrumb()) {\n        <div class=\"ax-text-xs ax-text-neutral-500 ax-mt-1\">{{ breadcrumb() }}</div>\n      }\n    </div>\n    @if (isLoadingDetails()) {\n      <div class=\"ax-flex ax-items-center ax-justify-center ax-py-8\">\n        <ax-loading>Loading details...</ax-loading>\n      </div>\n    } @else if (entityDetails()) {\n      <div class=\"ax-space-y-3 ax-mb-4\">\n        <!-- Important Entity Data -->\n        @if (entityDetails()?.entityData) {\n          <axp-widgets-container [context]=\"entityDetails()?.entityData\">\n            <div class=\"ax-space-y-2\">\n              @for (item of getEntityPropertiesWithWidgets(); track item.name) {\n                <div class=\"ax-flex ax-justify-between ax-items-center\">\n                  <span class=\"ax-text-sm ax-font-medium\">{{ item.title | translate | async }}:</span>\n                  <div class=\"ax-flex-1 ax-ml-2 ax-max-w-48\">\n                    <ng-container axp-widget-renderer [node]=\"item.node\" [mode]=\"'view'\"></ng-container>\n                  </div>\n                </div>\n              }\n            </div>\n          </axp-widgets-container>\n        }\n      </div>\n      <div class=\"ax-flex ax-gap-2 ax-justify-end ax-sm\">\n        <ax-button [color]=\"'primary'\" [look]=\"'solid'\" text=\"Open Details\" (click)=\"navigateToDetails()\"> </ax-button>\n      </div>\n    }\n  </div>\n</ax-popover>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i3.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: "ngmodule", type: AXPopoverModule }, { kind: "component", type: i2.AXPopoverComponent, selector: "ax-popover", inputs: ["width", "forceDisableActionSheetStyle", "disabled", "offsetX", "offsetY", "target", "placement", "content", "openOn", "closeOn", "hasBackdrop", "openAfter", "closeAfter", "repositionOnScroll", "backdropClass", "panelClass", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "ngmodule", type: AXPWidgetCoreModule }, { kind: "component", type: i3$1.AXPWidgetContainerComponent, selector: "axp-widgets-container", inputs: ["context", "functions"], outputs: ["onContextChanged"] }, { kind: "directive", type: i3$1.AXPWidgetRendererDirective, selector: "[axp-widget-renderer]", inputs: ["parentNode", "index", "mode", "node"], outputs: ["onOptionsChanged", "onValueChanged", "onLoad"], exportAs: ["widgetRenderer"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "ngmodule", type: AXLoadingModule }, { kind: "component", type: i4.AXLoadingComponent, selector: "ax-loading", inputs: ["visible", "type", "context"], outputs: ["visibleChange"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityDetailPopoverComponent, decorators: [{
             type: Component,
@@ -2919,6 +2891,12 @@ class AXPEntityMasterListViewModel {
             key: 'id',
         });
         this.selectedItems = signal([], ...(ngDevMode ? [{ debugName: "selectedItems" }] : []));
+        /**
+         * Selected category from the category sidebar (left panel).
+         * Used to set default category when creating new entities via command.
+         * Structure: { id: string; title: string } or null when "All Items" is selected.
+         */
+        this.selectedCategory = signal(null, ...(ngDevMode ? [{ debugName: "selectedCategory" }] : []));
         this.parentKey = computed(() => {
             return this.entityDef.parentKey;
         }, ...(ngDevMode ? [{ debugName: "parentKey" }] : []));
@@ -3189,6 +3167,13 @@ class AXPEntityMasterListViewModel {
     clearSelection() {
         this.selectedItems.set([]);
     }
+    /**
+     * Sets the selected category from the category sidebar.
+     * Call with null to clear (e.g. when "All Items" is selected).
+     */
+    setSelectedCategory(category) {
+        this.selectedCategory.set(category);
+    }
     async getPrimaryActions() {
         const scope = {};
         const actions = await Promise.all(this.allActions()
@@ -3352,6 +3337,8 @@ class AXPEntityMasterListViewModel {
         });
         const command = commandName.split('&')[0];
         const options = await this.evaluateExpressions(action?.options, data);
+        const baseData = action?.scope == AXPEntityCommandScope.Selected ? this.selectedItems() : data;
+        const commandData = this.mergeDefaultCategoryForCreate(command, baseData);
         if (this.workflow.exists(command)) {
             await this.workflow.execute(command, {
                 entity: getEntityInfo(this.entityDef).source,
@@ -3362,7 +3349,7 @@ class AXPEntityMasterListViewModel {
                     parentKey: this.entityDef.parentKey,
                     source: `${this.entityDef.module}.${this.entityDef.name}`,
                 },
-                data: action?.scope == AXPEntityCommandScope.Selected ? this.selectedItems() : data,
+                data: commandData,
                 options: options,
                 metadata: action?.metadata,
             });
@@ -3370,7 +3357,7 @@ class AXPEntityMasterListViewModel {
         else {
             const commandOptions = {
                 __context__: {
-                    data: action?.scope == AXPEntityCommandScope.Selected ? this.selectedItems() : data,
+                    data: commandData,
                     entity: getEntityInfo(this.entityDef).source,
                     entityInfo: {
                         name: this.entityDef.name,
@@ -3398,6 +3385,41 @@ class AXPEntityMasterListViewModel {
             // });
         }
     }
+    /**
+     * Merges default category from selected category in sidebar when executing create command.
+     * For Entity:Create and create-entity, if entity has category plugin and a category is selected,
+     * pre-fills categoryIds and categories for the create form.
+     */
+    mergeDefaultCategoryForCreate(command, baseData) {
+        const isCreateCommand = command === 'Entity:Create' || command === 'create-entity';
+        if (!isCreateCommand) {
+            return baseData;
+        }
+        const categoryExt = this.entityDef.extensions?.category;
+        if (!categoryExt) {
+            return baseData;
+        }
+        const selectedCat = this.selectedCategory();
+        if (!selectedCat) {
+            return baseData;
+        }
+        const propName = categoryExt.propertyName || 'categoryIds';
+        const valueField = categoryExt.valueField ?? 'id';
+        const textField = categoryExt.textField ?? 'title';
+        const idVal = selectedCat[valueField] ?? selectedCat.id;
+        const titleVal = selectedCat[textField] ?? selectedCat.title;
+        const defaultCategoryData = {
+            [propName]: [idVal],
+            categories: [{ [valueField]: idVal, [textField]: titleVal }],
+        };
+        if (baseData == null || (Array.isArray(baseData) && baseData.length === 0)) {
+            return defaultCategoryData;
+        }
+        if (typeof baseData === 'object' && !Array.isArray(baseData)) {
+            return { ...baseData, ...defaultCategoryData };
+        }
+        return baseData;
+    }
     async execute(command) {
         switch (command?.name) {
             case 'navigate':
@@ -5014,7 +5036,8 @@ class AXPPageListConverter extends AXPBaseRelatedEntityConverter {
         };
         // Don't evaluate actions here - keep expression strings for lazy evaluation at execution time
         // This ensures actions use the latest context data when executed
-        const actions = relatedEntity?.actions ?? [];
+        // const actions = relatedEntity?.actions ?? [];
+        const actions = await evaluateExpressions(relatedEntity?.actions ?? []);
         const filters = await Promise.all(relatedEntity.conditions?.map(async (c) => {
             const value = await evaluateExpressions(c.value);
             return {
@@ -5238,7 +5261,7 @@ class AXPTabListConverter extends AXPBaseRelatedEntityConverter {
         }) ?? []);
         // Don't evaluate actions here - keep expression strings for lazy evaluation at execution time
         // This ensures actions use the latest context data when executed
-        const actions = relatedEntity.actions;
+        const actions = await evaluateExpressions(relatedEntity.actions);
         return {
             id: entityDef?.name ?? '',
             title: relatedEntity.title ?? entityDef?.title ?? '',
@@ -6171,12 +6194,12 @@ const columnWidthMiddlewareProvider = {
  * Default order for common sections
  */
 const DEFAULT_SECTION_ORDER = {
-    'basic-info': 0,
+    'basic-info': -100,
     classification: 20,
-    appearance: 30,
-    settings: 100,
+    appearance: 90,
     advanced: 110,
     metadata: 120,
+    settings: 200,
 };
 /**
  * Default order for common properties
@@ -6640,11 +6663,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 +6834,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 +6880,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 +6940,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 +6949,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 +6994,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 +7415,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 +7435,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 +7577,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 +7600,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 +8181,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 +8356,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 +8455,6 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                 [titleField]="textField()"
                 [idField]="valueField()"
                 (onNodeSelect)="onNodeSelect($event)"
-                (onSelectionChange)="onSelectionChange($event)"
-                (onNodeToggle)="onNodeToggle($event)"
                 [nodeTemplate]="itemTemplate"
                 #tree
               >
@@ -8900,8 +8584,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
               >
@@ -12876,7 +12558,7 @@ class AXPLookupWidgetColumnComponent extends AXPColumnWidgetComponent {
         return get(item, this.displayField()) ?? '';
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPLookupWidgetColumnComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.16", type: AXPLookupWidgetColumnComponent, isStandalone: true, selector: "ng-component", inputs: { rawValue: "rawValue", rowData: "rowData" }, viewQueries: [{ propertyName: "moreButton", first: true, predicate: ["moreButton"], descendants: true, isSignal: true }, { propertyName: "morePopover", first: true, predicate: ["morePopover"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"ax-flex ax-gap-1 ax-items-center\">\n  @if (visibleItems().length > 0) {\n  @for (item of visibleItems(); track $index) {\n  <span class=\"ax-cursor-pointer hover:ax-text-primary hover:ax-underline\" (click)=\"handleItemClick($index)\">\n    {{ getDisplayText(item) }}\n  </span>\n  @if ($index < visibleItems().length - 1) { <span class=\"ax-text-muted\">\u2022</span>\n    }\n    }\n    } @else {\n    <span class=\"ax-text-muted\">---</span>\n    }\n\n    @if (hasMoreItems()) {\n    <span\n      class=\"ax-absolute ax-flex ax-items-center ax-end-0 ax-px-1 ax-cursor-pointer ax-h-full hover:ax-primary-lighter\"\n      (click)=\"showMoreItems()\" #moreButton>\n      <i class=\"fa-light fa-ellipsis-vertical\"></i>\n    </span>\n    }\n</div>\n\n<!-- More Items Popover -->\n<ax-popover [openOn]=\"'manual'\" #morePopover (openChange)=\"onMorePopoverOpenChange($event)\">\n  <div class=\"ax-lightest-surface ax-border ax-rounded-lg ax-shadow-lg ax-p-4 ax-min-w-[280px]\">\n    <div class=\"ax-mb-4 ax-border-b ax-pb-2\">\n      <h3 class=\"ax-text-base ax-font-semibold\">All {{ allItems().length }} Items</h3>\n    </div>\n    <div class=\"ax-max-h-64 ax-flex ax-flex-col ax-gap-3\">\n      @for (item of allItems(); track $index) {\n      <span class=\"ax-cursor-pointer hover:ax-text-primary hover:ax-underline\" (click)=\"showItemDetail(item, $index)\">\n        {{ getDisplayText(item) }}\n      </span>\n      }\n    </div>\n  </div>\n</ax-popover>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "component", type: i2.AXPopoverComponent, selector: "ax-popover", inputs: ["width", "disabled", "offsetX", "offsetY", "target", "placement", "content", "openOn", "closeOn", "hasBackdrop", "openAfter", "closeAfter", "repositionOnScroll", "backdropClass", "panelClass", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.16", type: AXPLookupWidgetColumnComponent, isStandalone: true, selector: "ng-component", inputs: { rawValue: "rawValue", rowData: "rowData" }, viewQueries: [{ propertyName: "moreButton", first: true, predicate: ["moreButton"], descendants: true, isSignal: true }, { propertyName: "morePopover", first: true, predicate: ["morePopover"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"ax-flex ax-gap-1 ax-items-center\">\n  @if (visibleItems().length > 0) {\n  @for (item of visibleItems(); track $index) {\n  <span class=\"ax-cursor-pointer hover:ax-text-primary hover:ax-underline\" (click)=\"handleItemClick($index)\">\n    {{ getDisplayText(item) }}\n  </span>\n  @if ($index < visibleItems().length - 1) { <span class=\"ax-text-muted\">\u2022</span>\n    }\n    }\n    } @else {\n    <span class=\"ax-text-muted\">---</span>\n    }\n\n    @if (hasMoreItems()) {\n    <span\n      class=\"ax-absolute ax-flex ax-items-center ax-end-0 ax-px-1 ax-cursor-pointer ax-h-full hover:ax-primary-lighter\"\n      (click)=\"showMoreItems()\" #moreButton>\n      <i class=\"fa-light fa-ellipsis-vertical\"></i>\n    </span>\n    }\n</div>\n\n<!-- More Items Popover -->\n<ax-popover [openOn]=\"'manual'\" #morePopover (openChange)=\"onMorePopoverOpenChange($event)\">\n  <div class=\"ax-lightest-surface ax-border ax-rounded-lg ax-shadow-lg ax-p-4 ax-min-w-[280px]\">\n    <div class=\"ax-mb-4 ax-border-b ax-pb-2\">\n      <h3 class=\"ax-text-base ax-font-semibold\">All {{ allItems().length }} Items</h3>\n    </div>\n    <div class=\"ax-max-h-64 ax-flex ax-flex-col ax-gap-3\">\n      @for (item of allItems(); track $index) {\n      <span class=\"ax-cursor-pointer hover:ax-text-primary hover:ax-underline\" (click)=\"showItemDetail(item, $index)\">\n        {{ getDisplayText(item) }}\n      </span>\n      }\n    </div>\n  </div>\n</ax-popover>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "component", type: i2.AXPopoverComponent, selector: "ax-popover", inputs: ["width", "forceDisableActionSheetStyle", "disabled", "offsetX", "offsetY", "target", "placement", "content", "openOn", "closeOn", "hasBackdrop", "openAfter", "closeAfter", "repositionOnScroll", "backdropClass", "panelClass", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPLookupWidgetColumnComponent, decorators: [{
             type: Component,
@@ -14711,11 +14393,11 @@ class AXPEntityModule {
                 useClass: AXPEntitiesListDataSourceDefinition,
                 multi: true,
             },
-            // {
-            //   provide: AXP_ENTITY_MODIFIER,
-            //   useValue: layoutOrderingMiddlewareProvider,
-            //   multi: true,
-            // },
+            {
+                provide: AXP_ENTITY_MODIFIER,
+                useValue: layoutOrderingMiddlewareProvider,
+                multi: true,
+            },
             provideCommandSetups([
                 {
                     key: 'Entity:OpenDetails',
@@ -14884,11 +14566,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                             useClass: AXPEntitiesListDataSourceDefinition,
                             multi: true,
                         },
-                        // {
-                        //   provide: AXP_ENTITY_MODIFIER,
-                        //   useValue: layoutOrderingMiddlewareProvider,
-                        //   multi: true,
-                        // },
+                        {
+                            provide: AXP_ENTITY_MODIFIER,
+                            useValue: layoutOrderingMiddlewareProvider,
+                            multi: true,
+                        },
                         provideCommandSetups([
                             {
                                 key: 'Entity:OpenDetails',
@@ -15052,7 +14734,7 @@ function entityMasterCrudActions(options) {
         create: true,
         delete: true,
         view: true,
-        edit: true,
+        edit: false,
         ...options,
     };
     const actions = [];