@acorex/platform 20.7.13 → 20.7.15

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

@@ -2043,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\n          [color]=\"'primary'\"\n          [look]=\"'solid'\"\n          [text]=\"'@general:actions.open-details.title' | translate | async\"\n          (click)=\"navigateToDetails()\"\n        >\n        </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 }); }
+    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\n          [color]=\"'primary'\"\n          [look]=\"'solid'\"\n          [text]=\"'@general:actions.open-details.title' | translate | async\"\n          (click)=\"navigateToDetails()\"\n        >\n        </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 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityDetailPopoverComponent, decorators: [{
             type: Component,
@@ -3864,7 +3864,7 @@ class AXPEntityPerformDeleteAction extends AXPWorkflowAction {
         for await (const entity of entities) {
             const [moduleName, entityName] = entity.source.split('.');
             const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
-            if (entityDefinition.parentKey && data[entityDefinition.parentKey]) {
+            if (data != null && entityDefinition.parentKey && data[entityDefinition.parentKey]) {
                 context.setVariable('meta', { ...meta, refreshTargetId: data[entityDefinition.parentKey] });
             }
             entityDefinitions[entity.source] = entityDefinition;
@@ -6446,7 +6446,6 @@ const AXPCrudModifier = {
             if (!queries?.list) {
                 queries.list = {
                     execute: async (e) => {
-                        console.log({ e });
                         return await dataService.query(e);
                     },
                     type: AXPEntityQueryType.List,
@@ -6531,12 +6530,28 @@ function isAXPMiddlewareAbortError(error) {
 const AXP_ENTITY_STORAGE_BACKEND = new InjectionToken('AXP_ENTITY_STORAGE_BACKEND');
 const AXP_ENTITY_STORAGE_MIDDLEWARE = new InjectionToken('AXP_ENTITY_STORAGE_MIDDLEWARE');
 
+/** In-flight request deduplication - parallel identical read requests share one execution */
+function getDedupKey(op, entityName, init) {
+    if (op === 'getOne' && init?.id !== undefined) {
+        return `getOne:${entityName}:${String(init.id)}`;
+    }
+    if (op === 'getAll') {
+        return `getAll:${entityName}`;
+    }
+    if (op === 'query' && init?.request) {
+        const r = init.request;
+        return `query:${entityName}:${r.skip ?? 0}:${r.take ?? 0}:${JSON.stringify(r.filter ?? null)}:${JSON.stringify(r.sort ?? null)}:${JSON.stringify(r.params ?? null)}`;
+    }
+    return '';
+}
 class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
     constructor() {
         super(...arguments);
         this.backend = inject(AXP_ENTITY_STORAGE_BACKEND);
         this.allMiddlewares = (inject(AXP_ENTITY_STORAGE_MIDDLEWARE, { optional: true }) || []).slice();
         this.injector = inject(EnvironmentInjector);
+        /** In-flight read requests - identical parallel requests share one execution */
+        this.inFlight = new Map();
     }
     get dbName() {
         return this.backend.dbName;
@@ -6595,6 +6610,19 @@ class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
         return this.run(ctx, () => this.backend.initial(ctx.entityName, ctx.data, options));
     }
     async getOne(entityName, id) {
+        const key = getDedupKey('getOne', entityName, { id });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('getOne', entityName, { id });
+                return this.run(ctx, () => this.backend.getOne(ctx.entityName, id));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
         const ctx = this.createCtx('getOne', entityName, { id });
         return this.run(ctx, () => this.backend.getOne(ctx.entityName, id));
     }
@@ -6611,13 +6639,47 @@ class AXPMiddlewareEntityStorageService extends AXPEntityStorageService {
         return this.run(ctx, () => this.backend.insertOne(ctx.entityName, ctx.data));
     }
     async getAll(entityName) {
+        const key = getDedupKey('getAll', entityName);
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('getAll', entityName);
+                return this.run(ctx, () => this.backend.getAll(ctx.entityName));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
         const ctx = this.createCtx('getAll', entityName);
         return this.run(ctx, () => this.backend.getAll(ctx.entityName));
     }
     async query(entityName, request) {
+        const key = getDedupKey('query', entityName, { request });
+        if (key) {
+            const existing = this.inFlight.get(key);
+            if (existing) {
+                return existing;
+            }
+            const promise = this.runWithDedup(key, () => {
+                const ctx = this.createCtx('query', entityName, { request });
+                return this.run(ctx, () => this.backend.query(ctx.entityName, request));
+            });
+            this.inFlight.set(key, promise);
+            return promise;
+        }
         const ctx = this.createCtx('query', entityName, { request });
         return this.run(ctx, () => this.backend.query(ctx.entityName, request));
     }
+    async runWithDedup(key, fn) {
+        try {
+            return await fn();
+        }
+        finally {
+            this.inFlight.delete(key);
+        }
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMiddlewareEntityStorageService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPMiddlewareEntityStorageService }); }
 }
@@ -6728,6 +6790,42 @@ class AXPCategoryTreeService {
             return null;
         }
     }
+    /**
+     * Fetches a single category item by ID. Uses byKey when available (full item with parent),
+     * otherwise falls back to list query with filter so ancestor chains can be built.
+     */
+    async fetchItemById(id, treeData, config) {
+        const byKey = treeData.categoryEntityDef?.queries?.byKey?.execute;
+        if (typeof byKey === 'function') {
+            try {
+                const item = await byKey(id);
+                return item ?? null;
+            }
+            catch (error) {
+                console.error('Error fetching category by key:', error);
+                return null;
+            }
+        }
+        if (!treeData.categoryEntityQueryFunc)
+            return null;
+        try {
+            const valueField = config.valueField ?? 'id';
+            const event = {
+                ...treeData.basicQueryEvent,
+                filter: {
+                    field: valueField,
+                    value: id,
+                    operator: { type: 'equal' },
+                },
+            };
+            const res = await treeData.categoryEntityQueryFunc(event);
+            return res?.items?.[0] ?? null;
+        }
+        catch (error) {
+            console.error('Error fetching category by id:', error);
+            return null;
+        }
+    }
     /**
      * Load children for a given node
      */
@@ -6812,8 +6910,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
         }] });
 
 class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
+    //#endregion
+    //#region ----   Lifecycle Methods   ----
     constructor() {
-        super(...arguments);
+        super();
         //#region ----   Services & Dependencies   ----
         this.categoryTreeService = inject(AXPCategoryTreeService);
         this.translationService = inject(AXTranslationService);
@@ -6826,6 +6926,8 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         this.valueField = signal('id', ...(ngDevMode ? [{ debugName: "valueField" }] : []));
         this.allowMultiple = signal(false, ...(ngDevMode ? [{ debugName: "allowMultiple" }] : []));
         this.selectedValues = signal([], ...(ngDevMode ? [{ debugName: "selectedValues" }] : []));
+        /** Optional input for when popup passes selected values via inputs instead of data */
+        this.selectedValuesInput = signal([], ...(ngDevMode ? [{ debugName: "selectedValuesInput" }] : []));
         this.searchPlaceholder = signal('@general:terms.interface.category.search.placeholder', ...(ngDevMode ? [{ debugName: "searchPlaceholder" }] : []));
         this.excludedNodeId = signal(undefined, ...(ngDevMode ? [{ debugName: "excludedNodeId" }] : [])); // Node ID to disable
         this.searchWithChildren = signal(true, ...(ngDevMode ? [{ debugName: "searchWithChildren" }] : [])); // Include children of search results
@@ -6863,6 +6965,7 @@ 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.initialExpandSyncDone = false;
         /** Datasource callback for tree-view component. */
         this.datasource = async (id) => {
             if (!this.treeData || !this.treeConfig) {
@@ -6954,9 +7057,22 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             }
             return childNodes;
         };
+        // When popup sets data after ngOnInit, run initial expand/sync when we get selected ids and tree is ready
+        effect(() => {
+            if (this.initialExpandSyncDone)
+                return;
+            const loading = this.loading();
+            const fromData = this.selectedValues().filter((id) => id && id !== 'all');
+            const fromInput = (this.selectedValuesInput() ?? []).filter((id) => id && id !== 'all');
+            const ids = fromData.length > 0 ? fromData : fromInput;
+            if (loading || ids.length === 0 || !this.treeData || !this.treeConfig)
+                return;
+            if (this.selectedNodeIds().length > 0)
+                return; // already set in initializeTree
+            this.initialExpandSyncDone = true;
+            this.runInitialExpandAndSync(ids);
+        });
     }
-    //#endregion
-    //#region ----   Lifecycle Methods   ----
     ngOnInit() {
         super.ngOnInit();
         this.initializeTree();
@@ -6984,15 +7100,14 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             if (this.treeData.categoryEntityDef?.parentKey) {
                 this.treeConfig.parentKey = this.treeData.categoryEntityDef.parentKey;
             }
-            // CRITICAL FIX: Parse initial selected values and set selectedNodeIds BEFORE tree renders.
-            // This allows the datasource callback to mark nodes as selected when they load.
-            // Previously, we tried to sync selection while loading was true, but the tree
-            // component doesn't exist until loading is false, causing sync methods to fail silently.
-            const initialSelectedIds = this.selectedValues().filter((id) => id && id !== 'all');
+            // Resolve initial selected IDs from data (popup) or input binding
+            const fromData = this.selectedValues().filter((id) => id && id !== 'all');
+            const fromInput = (this.selectedValuesInput() ?? []).filter((id) => id && id !== 'all');
+            const initialSelectedIds = fromData.length > 0 ? fromData : fromInput;
             if (initialSelectedIds.length > 0) {
-                // Load missing node data into cache first (needed for path calculation and node display)
                 await this.loadMissingNodeData(initialSelectedIds);
-                // Set selectedNodeIds so datasource callback can use it to mark nodes as selected
+                // Re-fetch any node that has no parent info (batch query may return minimal fields)
+                await this.ensureParentDataInCache(initialSelectedIds);
                 this.selectedNodeIds.set(initialSelectedIds);
             }
         }
@@ -7003,27 +7118,56 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             // Now let tree render by setting loading to false
             this.loading.set(false);
         }
-        // AFTER tree renders, perform selection sync operations.
-        // This must happen after loading.set(false) so the tree component exists in DOM.
+        // AFTER tree renders: wait for tree to exist, then expand path and sync selection
         const selectedIds = this.selectedNodeIds();
         if (selectedIds.length > 0) {
-            try {
-                // Wait for tree to render and stabilize
-                await new Promise((resolve) => setTimeout(resolve, 150));
-                // Build ancestor chains for path expansion (so selected nodes become visible)
-                const ancestorChains = await this.buildAncestorChains(selectedIds);
-                // Expand ancestor nodes to make selected nodes visible in tree
-                await this.expandAncestorNodesInOrder(ancestorChains);
-                // Wait for tree to process expansions
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                // Final sync to ensure all nodes are properly selected in tree component
-                await this.syncSelectionWithTree(selectedIds);
-            }
-            catch (error) {
-                console.error('Error syncing selection after tree render:', error);
-            }
+            this.initialExpandSyncDone = true;
+            this.runExpandAndSyncWhenTreeReady(selectedIds);
         }
     }
+    /**
+     * Called when popup data arrives after ngOnInit: load data, set selection, expand and sync.
+     */
+    runInitialExpandAndSync(ids) {
+        this.selectedNodeIds.set(ids);
+        Promise.resolve()
+            .then(() => this.loadMissingNodeData(ids))
+            .then(() => this.ensureParentDataInCache(ids))
+            .then(() => {
+            this.runExpandAndSyncWhenTreeReady(ids);
+        })
+            .catch((err) => console.error('Error in runInitialExpandAndSync:', err));
+    }
+    /**
+     * Runs expand path + sync selection once the tree viewChild is available.
+     * Uses retry loop so we don't run before the view has rendered the tree.
+     */
+    runExpandAndSyncWhenTreeReady(selectedIds) {
+        const maxWaitMs = 3500;
+        const pollMs = 80;
+        const start = Date.now();
+        const run = async () => {
+            while (Date.now() - start < maxWaitMs) {
+                const treeComponent = this.tree();
+                if (treeComponent) {
+                    try {
+                        await new Promise((resolve) => setTimeout(resolve, 320));
+                        const ancestorChains = await this.buildAncestorChains(selectedIds);
+                        await this.expandAncestorNodesInOrder(ancestorChains);
+                        await new Promise((resolve) => setTimeout(resolve, 120));
+                        await this.syncSelectionWithTree(selectedIds);
+                    }
+                    catch (error) {
+                        console.error('Error syncing selection after tree render:', error);
+                    }
+                    this.changeDetectorRef.markForCheck();
+                    return;
+                }
+                await new Promise((resolve) => setTimeout(resolve, pollMs));
+            }
+        };
+        run();
+    }
     //#endregion
     //#region ----   Public Methods   ----
     /**
@@ -7298,29 +7442,13 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         }
     }
     /**
-     * Fetches a single item by ID from the server
+     * Fetches a single item by ID. Uses category tree service so byKey is used when available
+     * (returns full item with parent/parentId for building ancestor chains).
      */
     async fetchItemById(id) {
-        if (!this.treeData?.categoryEntityQueryFunc) {
-            return null;
-        }
-        try {
-            const valueField = this.treeConfig?.valueField || 'id';
-            const event = {
-                ...this.treeData.basicQueryEvent,
-                filter: {
-                    field: valueField,
-                    value: id,
-                    operator: { type: 'equal' },
-                },
-            };
-            const res = await this.treeData.categoryEntityQueryFunc(event);
-            return res?.items?.[0] ?? null;
-        }
-        catch (error) {
-            console.error('Error fetching item by ID:', error);
+        if (!this.treeData || !this.treeConfig)
             return null;
-        }
+        return this.categoryTreeService.fetchItemById(id, this.treeData, this.treeConfig);
     }
     /**
      * Sorts parent IDs by their depth (root first, leaves last)
@@ -7357,7 +7485,7 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                     break;
                 }
                 itemCache.set(currentId, item);
-                currentId = item[parentKey] ? String(item[parentKey]) : null;
+                currentId = this.getParentIdFromNodeData(item);
             }
             if (missingIds.size === 0 || !missingIds.has(parentId)) {
                 depthMap.set(parentId, depth);
@@ -7387,7 +7515,7 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                     depth++;
                     const item = this.nodeDataCache.get(currentId) || itemCache.get(currentId);
                     if (item) {
-                        currentId = item[parentKey] ? String(item[parentKey]) : null;
+                        currentId = this.getParentIdFromNodeData(item);
                     }
                     else {
                         break;
@@ -7836,35 +7964,33 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
      */
     async buildAncestorChains(selectedIds) {
         const ancestorChains = new Map();
-        if (!this.treeData || !this.treeConfig) {
+        if (!this.treeData || !this.treeConfig)
             return ancestorChains;
-        }
-        const parentKey = this.treeData.categoryEntityDef?.parentKey;
-        if (!parentKey) {
-            // No parent key means flat structure
+        if (!this.treeData.categoryEntityDef?.parentKey)
             return ancestorChains;
-        }
         for (const nodeId of selectedIds) {
             const chain = [];
-            let currentData = this.nodeDataCache.get(nodeId);
-            if (!currentData) {
+            let currentData = this.nodeDataCache.get(nodeId) ?? null;
+            if (!currentData)
                 continue;
+            if (!this.getParentIdFromNodeData(currentData)) {
+                const refetched = await this.fetchItemById(nodeId);
+                if (refetched) {
+                    currentData = refetched;
+                    this.nodeDataCache.set(nodeId, refetched);
+                }
             }
-            // Traverse up to root, collecting ancestor IDs
             const visited = new Set();
             while (currentData) {
-                const parentId = currentData[parentKey];
-                if (!parentId || parentId === 'all' || visited.has(String(parentId))) {
+                const parentId = this.getParentIdFromNodeData(currentData);
+                if (!parentId || visited.has(parentId))
                     break;
-                }
-                const parentIdStr = String(parentId);
-                visited.add(parentIdStr);
-                chain.unshift(parentIdStr); // Add to beginning (root first)
-                // Load parent data if not cached
-                if (!this.nodeDataCache.has(parentIdStr)) {
-                    const parentData = await this.fetchItemById(parentIdStr);
+                visited.add(parentId);
+                chain.unshift(parentId);
+                if (!this.nodeDataCache.has(parentId)) {
+                    const parentData = await this.fetchItemById(parentId);
                     if (parentData) {
-                        this.nodeDataCache.set(parentIdStr, parentData);
+                        this.nodeDataCache.set(parentId, parentData);
                         currentData = parentData;
                     }
                     else {
@@ -7872,7 +7998,7 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                     }
                 }
                 else {
-                    currentData = this.nodeDataCache.get(parentIdStr);
+                    currentData = this.nodeDataCache.get(parentId) ?? null;
                 }
             }
             ancestorChains.set(nodeId, chain);
@@ -7905,30 +8031,41 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         const sortedAncestors = Array.from(allAncestors).sort((a, b) => {
             return (ancestorDepths.get(a) ?? 0) - (ancestorDepths.get(b) ?? 0);
         });
-        // First expand root node if not expanded
         try {
             if (!treeComponent.isNodeExpanded('all')) {
                 await treeComponent.expandNode('all');
-                await new Promise((resolve) => setTimeout(resolve, 50));
+                await this.waitForNodeExpanded(treeComponent, 'all');
             }
         }
         catch {
             // Root might not exist
         }
-        // Expand ancestors in order - this loads them into the tree via datasource callback
         for (const ancestorId of sortedAncestors) {
             try {
                 if (!treeComponent.isNodeExpanded(ancestorId)) {
                     await treeComponent.expandNode(ancestorId);
-                    // Small delay to allow tree to process the expansion
-                    await new Promise((resolve) => setTimeout(resolve, 30));
+                    await this.waitForNodeExpanded(treeComponent, ancestorId);
                 }
             }
             catch {
-                // Ancestor might not be in tree yet, continue
+                // Ancestor might not be in tree yet
             }
         }
     }
+    /** Waits until the node is expanded (tree has loaded children). Polls so deep paths load. */
+    async waitForNodeExpanded(treeComponent, nodeId, maxWaitMs = 2800, pollMs = 60) {
+        const deadline = Date.now() + maxWaitMs;
+        while (Date.now() < deadline) {
+            try {
+                if (treeComponent.isNodeExpanded(nodeId))
+                    return;
+            }
+            catch {
+                // Node may not exist yet
+            }
+            await new Promise((r) => setTimeout(r, pollMs));
+        }
+    }
     /**
      * Syncs selection state with the tree component.
      * Selects leaf nodes and manually updates parent states (indeterminate/selected).
@@ -8014,15 +8151,13 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
             if (!nodeData) {
                 continue;
             }
-            // Traverse up the parent chain
             let currentData = nodeData;
             while (currentData) {
-                const parentId = currentData[parentKey];
-                if (!parentId || parentId === 'all') {
+                const parentId = this.getParentIdFromNodeData(currentData);
+                if (!parentId)
                     break;
-                }
-                parentsToUpdate.add(String(parentId));
-                currentData = this.nodeDataCache.get(String(parentId));
+                parentsToUpdate.add(parentId);
+                currentData = this.nodeDataCache.get(parentId);
             }
         }
         // Sort parents by depth (deepest first so we update bottom-up)
@@ -8114,44 +8249,57 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         if (!this.treeData || !this.treeConfig || selectedIds.length === 0) {
             return;
         }
-        // Find IDs that are selected but not in cache
         const missingIds = selectedIds.filter((id) => !this.nodeDataCache.has(id));
-        if (missingIds.length === 0) {
+        if (missingIds.length === 0)
             return;
-        }
         try {
+            // Prefer fetching each id via service (uses byKey when available = full item with parent)
             const valueField = this.treeConfig.valueField || 'id';
-            const categoryEntityQueryFunc = this.treeData.categoryEntityQueryFunc;
-            if (!categoryEntityQueryFunc) {
-                return;
-            }
-            // Query for missing nodes by their IDs
-            const event = {
-                ...this.treeData.basicQueryEvent,
-                filter: {
-                    filters: missingIds.map((id) => ({
-                        field: valueField,
-                        value: id,
-                        operator: { type: 'equal' },
-                    })),
-                    logic: 'or',
-                },
-            };
-            const res = await categoryEntityQueryFunc(event);
-            if (res?.items) {
-                // Cache the fetched node data
-                res.items.forEach((item) => {
-                    const itemId = String(item[valueField] ?? '');
-                    if (itemId) {
-                        this.nodeDataCache.set(itemId, item);
-                    }
-                });
+            for (const id of missingIds) {
+                const item = await this.fetchItemById(id);
+                if (item)
+                    this.nodeDataCache.set(String(item[valueField] ?? id), item);
             }
         }
         catch (error) {
             console.error('Error loading missing node data:', error);
         }
     }
+    /**
+     * For each selected id, if cached item has no parent (e.g. batch query returned minimal fields),
+     * re-fetch by id so we have parent/parentId for building ancestor chains.
+     */
+    async ensureParentDataInCache(selectedIds) {
+        if (!this.treeConfig)
+            return;
+        for (const id of selectedIds) {
+            const cached = this.nodeDataCache.get(id);
+            if (cached && this.getParentIdFromNodeData(cached) === null) {
+                const full = await this.fetchItemById(id);
+                if (full)
+                    this.nodeDataCache.set(id, full);
+            }
+        }
+    }
+    /**
+     * Resolves parent ID from node data: supports nested `parent` object or flat parentId/parentKey.
+     */
+    getParentIdFromNodeData(item) {
+        if (!item || !this.treeConfig)
+            return null;
+        const valueField = this.treeConfig.valueField || 'id';
+        const parentKey = this.treeData?.categoryEntityDef?.parentKey || 'parentId';
+        const parent = item['parent'];
+        if (parent && typeof parent === 'object') {
+            const id = String(parent[valueField] ?? parent['id'] ?? '');
+            return id && id !== 'all' ? id : null;
+        }
+        const parentIdValue = item[parentKey] ?? item['parentId'];
+        if (parentIdValue == null || parentIdValue === '')
+            return null;
+        const id = String(parentIdValue);
+        return id && id !== 'all' ? id : null;
+    }
     /**
      * Marks nodes as selected in the tree structure based on selectedNodeIds.
      * This ensures pre-selected nodes appear selected when the tree is rendered.
@@ -8337,29 +8485,18 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         while (currentId && currentData && !visitedIds.has(currentId)) {
             visitedIds.add(currentId);
             const title = this.getNodeTitle(currentData);
-            if (title) {
+            if (title)
                 path.unshift(title);
-            }
-            const parentId = currentData[parentKey];
-            if (!parentId || parentId === 'all' || parentId === currentId) {
+            const parentId = this.getParentIdFromNodeData(currentData);
+            if (!parentId || parentId === currentId)
                 break;
-            }
-            let parentData = this.nodeDataCache.get(String(parentId));
+            let parentData = this.nodeDataCache.get(parentId);
             if (!parentData && this.treeData.categoryEntityQueryFunc) {
                 try {
-                    const valueField = this.treeConfig.valueField || 'id';
-                    const event = {
-                        ...this.treeData.basicQueryEvent,
-                        filter: {
-                            field: valueField,
-                            value: parentId,
-                            operator: { type: 'equal' },
-                        },
-                    };
-                    const res = await this.treeData.categoryEntityQueryFunc(event);
-                    if (res?.items && res.items.length > 0) {
-                        parentData = res.items[0];
-                        this.nodeDataCache.set(String(parentId), parentData);
+                    const fetched = await this.fetchItemById(parentId);
+                    if (fetched) {
+                        parentData = fetched;
+                        this.nodeDataCache.set(parentId, fetched);
                     }
                 }
                 catch (error) {
@@ -8367,10 +8504,9 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
                     break;
                 }
             }
-            if (!parentData) {
+            if (!parentData)
                 break;
-            }
-            currentId = String(parentId);
+            currentId = parentId;
             currentData = parentData;
         }
         return path.length > 0 ? path : this.getNodeTitle(nodeData) ? [this.getNodeTitle(nodeData)] : [];
@@ -8434,7 +8570,7 @@ class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent {
         }));
         return items.filter((item) => item != null);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityCategoryTreeSelectorComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityCategoryTreeSelectorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
     static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.16", type: AXPEntityCategoryTreeSelectorComponent, isStandalone: true, selector: "axp-entity-category-tree-selector", viewQueries: [{ propertyName: "tree", first: true, predicate: ["tree"], descendants: true, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
     <div class="ax-flex ax-flex-col ax-h-full">
       @if (loading()) {
@@ -8703,7 +8839,211 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                         FormsModule,
                     ],
                 }]
-        }], propDecorators: { tree: [{ type: i0.ViewChild, args: ['tree', { isSignal: true }] }] } });
+        }], ctorParameters: () => [], propDecorators: { tree: [{ type: i0.ViewChild, args: ['tree', { isSignal: true }] }] } });
+
+/**
+ * Batch-resolves category data for entity-category-widget-column.
+ * Only fetches when the column is visible. Returns full path for hierarchical display (e.g. "… > Sales").
+ */
+class AXPEntityCategoryBatchResolverService {
+    constructor() {
+        this.entityResolver = inject(AXPEntityDefinitionRegistryService);
+        this.entityStorage = inject(AXPEntityStorageService);
+        this.cache = new Map();
+        this.pendingByEntity = new Map();
+        this.flushScheduled = false;
+    }
+    async resolve(entityKey, ids, valueField, textField, parentKey) {
+        const uniqueIds = Array.from(new Set(ids.filter((id) => id != null && id !== '')));
+        if (uniqueIds.length === 0)
+            return new Map();
+        const cached = this.getFromCache(entityKey, uniqueIds, valueField);
+        if (cached.size === uniqueIds.length)
+            return cached;
+        return new Promise((resolve, reject) => {
+            const list = this.pendingByEntity.get(entityKey) ?? [];
+            list.push({
+                ids: uniqueIds,
+                valueField,
+                textField,
+                parentKey,
+                resolve: (m) => {
+                    const subset = new Map();
+                    for (const id of uniqueIds) {
+                        const r = m.get(id);
+                        if (r)
+                            subset.set(id, r);
+                    }
+                    resolve(subset);
+                },
+                reject,
+            });
+            this.pendingByEntity.set(entityKey, list);
+            this.scheduleFlush();
+        });
+    }
+    getFromCache(entityKey, ids, valueField) {
+        const entityCache = this.cache.get(entityKey);
+        if (!entityCache)
+            return new Map();
+        const result = new Map();
+        for (const id of ids) {
+            const cached = entityCache.get(id);
+            if (cached)
+                result.set(id, cached);
+        }
+        return result;
+    }
+    setCache(entityKey, items, valueField) {
+        let entityCache = this.cache.get(entityKey);
+        if (!entityCache) {
+            entityCache = new Map();
+            this.cache.set(entityKey, entityCache);
+        }
+        for (const item of items) {
+            entityCache.set(item.id, item);
+        }
+    }
+    scheduleFlush() {
+        if (this.flushScheduled)
+            return;
+        this.flushScheduled = true;
+        queueMicrotask(() => {
+            this.flushScheduled = false;
+            this.flushAll();
+        });
+    }
+    async flushAll() {
+        const entities = Array.from(this.pendingByEntity.keys());
+        for (const entityKey of entities) {
+            await this.flush(entityKey);
+        }
+    }
+    async flush(entityKey) {
+        const list = this.pendingByEntity.get(entityKey);
+        if (!list?.length)
+            return;
+        this.pendingByEntity.delete(entityKey);
+        const first = list[0];
+        const { valueField, textField, parentKey } = first;
+        const allIds = Array.from(new Set(list.flatMap((r) => r.ids)));
+        try {
+            const result = await this.fetchAndResolve(entityKey, allIds, valueField, textField, parentKey);
+            for (const req of list) {
+                const subset = new Map();
+                for (const id of req.ids) {
+                    const r = result.get(id);
+                    if (r)
+                        subset.set(id, r);
+                }
+                req.resolve(subset);
+            }
+        }
+        catch (err) {
+            for (const req of list)
+                req.reject(err);
+        }
+    }
+    async fetchAndResolve(entityKey, ids, valueField, textField, parentKey) {
+        const [moduleName, entityName] = entityKey.split('.');
+        if (!moduleName || !entityName)
+            return new Map();
+        try {
+            let items;
+            let allItems;
+            if (parentKey) {
+                // Use storage directly to fetch ALL categories. The entity's list execute adds
+                // a default filter (parentId isEmpty) that returns only roots - we need the full tree.
+                const allResult = await this.entityStorage.query(entityKey, {
+                    skip: 0,
+                    take: 10000,
+                });
+                allItems = allResult?.items ?? [];
+                items = allItems.filter((c) => ids.includes(String(get(c, valueField))));
+            }
+            else {
+                const entityDef = await this.entityResolver.resolve(moduleName, entityName);
+                const listExecute = entityDef?.queries?.list?.execute;
+                if (!listExecute || typeof listExecute !== 'function')
+                    return new Map();
+                const result = await listExecute({
+                    skip: 0,
+                    take: ids.length + 100,
+                    filter: { field: valueField, operator: { type: 'in' }, value: ids },
+                });
+                items = result?.items ?? [];
+                allItems = items;
+            }
+            const pathMap = parentKey
+                ? this.buildPathMap(allItems, valueField, textField, parentKey)
+                : null;
+            const result = new Map();
+            for (const item of items) {
+                const id = String(get(item, valueField));
+                const title = get(item, textField);
+                const path = pathMap
+                    ? pathMap.get(id) ?? (title != null ? [String(title)] : [])
+                    : title != null && title !== ''
+                        ? [String(title)]
+                        : [];
+                result.set(id, {
+                    id,
+                    title: title != null ? String(title) : '',
+                    path,
+                });
+            }
+            this.setCache(entityKey, Array.from(result.values()), valueField);
+            return result;
+        }
+        catch (error) {
+            console.error('[EntityCategoryBatchResolver] Failed:', error);
+            return new Map();
+        }
+    }
+    buildPathMap(items, valueField, textField, parentKey) {
+        const map = new Map();
+        for (const item of items) {
+            map.set(String(get(item, valueField)), item);
+        }
+        const pathMap = new Map();
+        const visited = new Set();
+        const buildPath = (id) => {
+            if (visited.has(id))
+                return pathMap.get(id) ?? [];
+            const item = map.get(id);
+            if (!item)
+                return [];
+            const parentId = get(item, parentKey);
+            const title = String(get(item, textField) ?? '');
+            if (parentId == null ||
+                parentId === '' ||
+                parentId === 'all' ||
+                String(parentId) === id) {
+                const path = title ? [title] : [];
+                pathMap.set(id, path);
+                visited.add(id);
+                return path;
+            }
+            const parentPath = buildPath(String(parentId));
+            const path = title ? [...parentPath, title] : parentPath;
+            pathMap.set(id, path);
+            visited.add(id);
+            return path;
+        };
+        for (const item of items) {
+            const id = String(get(item, valueField));
+            if (!pathMap.has(id))
+                buildPath(id);
+        }
+        return pathMap;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityCategoryBatchResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityCategoryBatchResolverService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPEntityCategoryBatchResolverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 class AXPEntityCategoryWidgetColumnComponent extends AXPColumnWidgetComponent {
     constructor() {
@@ -8712,6 +9052,7 @@ class AXPEntityCategoryWidgetColumnComponent extends AXPColumnWidgetComponent {
         this.entityDetailPopoverService = inject(AXPEntityDetailPopoverService);
         this.formatService = inject(AXFormatService);
         this.entityResolver = inject(AXPEntityDefinitionRegistryService);
+        this.categoryBatchResolver = inject(AXPEntityCategoryBatchResolverService);
         //#endregion
         //#region ----   Inputs   ----
         this.rawValueSignal = signal(null, ...(ngDevMode ? [{ debugName: "rawValueSignal" }] : []));
@@ -8763,7 +9104,7 @@ class AXPEntityCategoryWidgetColumnComponent extends AXPColumnWidgetComponent {
             }
             else {
                 const items = castArray(value);
-                const itemsWithPaths = await Promise.all(items.map((item) => this.extractItemWithPath(item)));
+                const itemsWithPaths = await this.resolveItemsWithPaths(items);
                 this.displayItems.set(itemsWithPaths.filter((c) => c != null));
             }
         }, ...(ngDevMode ? [{ debugName: "efDisplay" }] : []));
@@ -8852,55 +9193,109 @@ class AXPEntityCategoryWidgetColumnComponent extends AXPColumnWidgetComponent {
     }
     //#endregion
     //#region ----   Private Methods   ----
-    async extractItemWithPath(item) {
-        if (isNil(item)) {
-            return null;
+    async resolveItemsWithPaths(items) {
+        const entityKey = this.entity();
+        const valueField = this.valueField();
+        const textField = this.displayField();
+        const parentKey = this.entityDef()?.parentKey ?? (entityKey?.endsWith('Category') ? 'parentId' : undefined);
+        // When record has categories: [{id, parentId, title}] from middleware, build path from chain
+        const hasFullChain = items.some((item) => item &&
+            typeof item === 'object' &&
+            get(item, 'parentId') != null &&
+            get(item, valueField) != null);
+        if (hasFullChain && items.length > 0) {
+            return items
+                .filter((item) => item != null)
+                .map((item) => this.buildItemWithPathFromChain(item, items, valueField, textField, parentKey ?? 'parentId'));
+        }
+        const needsResolve = items.filter((item) => {
+            if (isNil(item))
+                return false;
+            if (typeof item !== 'object')
+                return true;
+            const idVal = get(item, valueField);
+            const hasPath = item.path && Array.isArray(item.path) && item.path.length > 0;
+            return !hasPath && idVal != null && idVal !== '';
+        });
+        const idsToResolve = needsResolve.map((item) => typeof item === 'object' ? String(get(item, valueField)) : String(item));
+        let resolvedMap = new Map();
+        if (idsToResolve.length > 0 && entityKey) {
+            resolvedMap = await this.categoryBatchResolver.resolve(entityKey, idsToResolve, valueField, textField, parentKey);
+        }
+        return Promise.all(items.map((item) => this.extractItemWithPath(item, resolvedMap)));
+    }
+    /**
+     * Build path from categories array when record has full chain (id, parentId, title).
+     * Used when middleware enriches categories on create/update.
+     */
+    buildItemWithPathFromChain(item, allItems, valueField, textField, parentKey) {
+        const map = new Map();
+        for (const c of allItems) {
+            const id = get(c, valueField);
+            if (id != null)
+                map.set(String(id), c);
+        }
+        const path = [];
+        let current = item;
+        const visited = new Set();
+        while (current) {
+            const id = String(get(current, valueField) ?? '');
+            if (!id || visited.has(id))
+                break;
+            visited.add(id);
+            const title = String(get(current, textField) ?? '');
+            if (title)
+                path.unshift(title);
+            const parentId = get(current, parentKey);
+            if (parentId == null || parentId === '' || String(parentId) === id)
+                break;
+            current = map.get(String(parentId));
         }
+        const pathArray = path.length > 0 ? path : get(item, textField) ? [String(get(item, textField))] : [];
+        return {
+            [valueField]: get(item, valueField),
+            [textField]: get(item, textField),
+            path: pathArray,
+        };
+    }
+    async extractItemWithPath(item, resolvedMap) {
+        if (isNil(item))
+            return null;
+        const valueField = this.valueField();
+        const textField = this.displayField();
         let itemObj;
         if (typeof item === 'object') {
             itemObj = item;
-            // If the provided object lacks a computed path, try to enrich it by fetching the full record
-            // so we have access to parent information for accurate path computation.
-            if (!itemObj.path || !Array.isArray(itemObj.path) || itemObj.path.length === 0) {
-                const byKey = this.entityDef()?.queries?.byKey?.execute;
-                const idVal = get(itemObj, this.valueField());
-                if (byKey && idVal != null && idVal !== '') {
-                    try {
-                        const fetched = await byKey(idVal);
-                        if (fetched) {
-                            itemObj = fetched;
-                        }
-                    }
-                    catch (error) {
-                        console.error('Error fetching full item for path calculation:', error);
-                    }
+            const idVal = get(itemObj, valueField);
+            const hasPath = itemObj.path && Array.isArray(itemObj.path) && itemObj.path.length > 0;
+            if (!hasPath && resolvedMap && idVal != null && idVal !== '') {
+                const r = resolvedMap.get(String(idVal));
+                if (r) {
+                    itemObj = {
+                        [valueField]: r.id,
+                        [textField]: r.title,
+                        path: r.path,
+                    };
                 }
             }
         }
         else {
-            // If item is just an ID, fetch the full item
-            const byKey = this.entityDef()?.queries?.byKey?.execute;
-            if (byKey) {
-                try {
-                    itemObj = await byKey(item);
+            if (resolvedMap) {
+                const r = resolvedMap.get(String(item));
+                if (r) {
+                    itemObj = { [valueField]: r.id, [textField]: r.title, path: r.path };
                 }
-                catch (error) {
-                    console.error('Error fetching item:', error);
-                    return null;
+                else {
+                    itemObj = { [valueField]: item, [textField]: item, path: [String(item)] };
                 }
             }
             else {
-                itemObj = {
-                    [this.valueField()]: item,
-                    [this.textField()]: item,
-                };
+                itemObj = { [valueField]: item, [textField]: item, path: [String(item)] };
             }
         }
-        // If item already has a path array, return it as is
         if (itemObj.path && Array.isArray(itemObj.path) && itemObj.path.length > 0) {
             return itemObj;
         }
-        // Calculate path for the item
         return await this.calculateItemPath(itemObj);
     }
     /**
@@ -9460,6 +9855,7 @@ class AXPEntityCategoryWidgetEditComponent extends AXPValueWidgetComponent {
                     selectedValues: signal(selectedIds),
                     searchPlaceholder: signal(this.searchPlaceholderText()),
                     excludedNodeId: signal(excludedNodeId),
+                    selectedValuesInput: signal(selectedIds),
                 },
             });
             if (result?.data?.selected && Array.isArray(result.data.selected)) {
@@ -10208,6 +10604,11 @@ class AXPEntityListTableService {
             parentField: entity.parentKey,
             fetchDataMode: 'manual',
             minHeight: 250,
+            // ⏳ Loading Configuration
+            loading: {
+                enabled: true,
+                animation: true,
+            },
             // 🎪 Events
             ...this.createDefaultEvents(entity, allActions),
         };
@@ -10744,25 +11145,27 @@ class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
         };
         const listOptions = await this.entityListTableService.convertEntityToListOptions(resolvedEntity, options, this.allActions());
         const toolbarOptions = await this.entityListToolbarService.convertEntityToolbarOptions(resolvedEntity, options);
-        this.listNode.set({
-            type: AXPWidgetsCatalog.dataList,
-            options: listOptions,
-            path: `table`,
-            name: 'table',
-            mode: 'view',
-            defaultValue: this.getValue()?.table,
-        });
-        this.toolbarNode.set({
-            type: AXPWidgetsCatalog.listToolbar,
-            path: `toolbar`,
-            options: toolbarOptions,
-            mode: 'view',
-            defaultValue: {
-                filters: this.getValue()?.toolbar?.filters,
-                sorts: this.getValue()?.toolbar?.sorts,
-                columns: this.getValue()?.toolbar?.columns,
-            },
-        });
+        setTimeout(() => {
+            this.listNode.set({
+                type: AXPWidgetsCatalog.dataList,
+                options: listOptions,
+                path: `table`,
+                name: 'table',
+                mode: 'view',
+                defaultValue: this.getValue()?.table,
+            });
+            this.toolbarNode.set({
+                type: AXPWidgetsCatalog.listToolbar,
+                path: `toolbar`,
+                options: toolbarOptions,
+                mode: 'view',
+                defaultValue: {
+                    filters: this.getValue()?.toolbar?.filters,
+                    sorts: this.getValue()?.toolbar?.sorts,
+                    columns: this.getValue()?.toolbar?.columns,
+                },
+            });
+        }, 100);
     }
     async ngAfterViewInit() {
         this.workflow.events$
@@ -12565,7 +12968,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", "forceDisableActionSheetStyle", "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", "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,
@@ -14193,6 +14596,8 @@ class AXPShowFileUploaderPopupAction extends AXPWorkflowAction {
         const maxFileSize = context.getVariable('options.maxFileSize');
         const files = context.getVariable('options.files');
         const fileEditable = context.getVariable('options.fileEditable');
+        const enableTitleDescription = context.getVariable('options.enableTitleDescription');
+        const showEditDialogAfterSelect = context.getVariable('options.showEditDialogAfterSelect');
         //check is correct file
         const correctFiles = files.filter((item) => item != undefined);
         // *********** show file list ***********
@@ -14202,9 +14607,10 @@ class AXPShowFileUploaderPopupAction extends AXPWorkflowAction {
             multiple: multiple,
             accept: accept,
             fileEditable: fileEditable,
+            enableTitleDescription: enableTitleDescription ?? false,
+            showEditDialogAfterSelect: showEditDialogAfterSelect ?? false,
             // maxFileSize: maxFileSize,
         });
-        debugger;
         // Handle case when result is undefined or empty array
         if (!res) {
             context.setOutput('result', false);
@@ -14213,7 +14619,6 @@ class AXPShowFileUploaderPopupAction extends AXPWorkflowAction {
         // *********** save files to entity ***********
         const [module, entity] = context.getVariable('entity').split('.');
         const entityDefinition = await this.entityRegistryService.resolve(module, entity);
-        debugger;
         if (entityDefinition) {
             const updateExec = entityDefinition.commands?.update?.execute;
             const entityData = await updateExec({
@@ -14221,7 +14626,10 @@ class AXPShowFileUploaderPopupAction extends AXPWorkflowAction {
                 [key]: res,
             });
             context.setOutput('result', true);
-            context.setVariable('data', cloneDeep(entityData));
+            // Merge full file list (name, title, description) from popup into returned data so
+            // workflow output includes title/description when enableTitleDescription is used
+            const dataWithFiles = { ...entityData, [key]: res };
+            context.setVariable('data', cloneDeep(dataWithFiles));
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AXPShowFileUploaderPopupAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }