@acorex-platform/module-location-management-client 0.0.15 → 0.0.18

package/fesm2022/acorex-platform-module-location-management-client.mjs

@@ -0,0 +1,1955 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, signal, effect, computed, HostBinding, ChangeDetectionStrategy, Component, NgModule } from '@angular/core';
+import { AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/core';
+import { AXPEntityService, AXP_ENTITY_STORAGE_BACKEND, AXP_ENTITY_DEFINITION_LOADER, AXP_ENTITY_STORAGE_MIDDLEWARE } from '@acorex-platform/framework-client/layout/entity';
+import { RootConfig, AXMLocationManagementPermissionsKeys, AXPLocationManagementMenuKeys, AXMLocationManagementDataSourceKeys, buildLocationAssignmentLocationSnapshot, buildLocationAssignmentPersonSnapshot } from '@acorex-platform/module-location-management-client/contracts';
+import { AXPSearchCommandProvider, createEntityCommandOptions, AXPSettingsService, AXPClipBoardService, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXP_WIDGETS_EDITOR_SUB_COMPOSITE, AXP_WIDGETS_EDITOR_CATEGORY, AXPValueWidgetComponent, AXPColumnWidgetComponent, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/layout/widget-core';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { AXPCommonMenuKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXPWidgetsCatalog, AXPPlatformScope, formatAddressData, extractValue } from '@acorex-platform/framework-shared/core';
+import { AXDataSource } from '@acorex/cdk/common';
+import { get, set, defaultTo, isEmpty, isEqual, isNil, isNull } from 'lodash';
+import { createSelectProperty, createBooleanProperty, AXPWidgetGroupEnum } from '@acorex-platform/framework-shared/widget-core';
+import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXP_DISABLED_PROPERTY, AXP_HAS_LABEL_PROPERTY, AXP_PLACEHOLDER_PROPERTY, AXP_BEHAVIOR_PROPERTY_GROUP } from '@acorex-platform/framework-client/layout/widgets';
+import * as i6 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i4 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i3 from '@acorex/components/form';
+import { AXFormModule } from '@acorex/components/form';
+import * as i5 from '@acorex/components/text-box';
+import { AXTextBoxModule } from '@acorex/components/text-box';
+import { AXValidationModule } from '@acorex/core/validation';
+import { AXPLayoutBuilderService, AXPLayoutRendererComponent } from '@acorex-platform/framework-client/layout/builder';
+import * as i2 from '@angular/forms';
+import { FormsModule } from '@angular/forms';
+import * as i7 from '@acorex/components/accordion';
+import { AXAccordionModule } from '@acorex/components/accordion';
+import * as i1$1 from '@acorex/components/badge';
+import { AXBadgeModule } from '@acorex/components/badge';
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Location Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const LocationManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    required: true,
+    // Module dependencies (optional)
+};
+//#endregion
+
+class AXMLocationManagementPermissionDefinitionProvider {
+    constructor(injector) {
+        this.injector = injector;
+        this.translateService = this.injector.get(AXTranslationService);
+    }
+    async define(context) {
+        const keys = AXMLocationManagementPermissionsKeys.LocationManagement;
+        const moduleTitle = await this.translateService.translateAsync('@location-management:module.permissions.title');
+        const moduleDescription = await this.translateService.translateAsync('@location-management:module.permissions.description');
+        context.addGroup(RootConfig.module.name, moduleTitle, moduleDescription)
+            // Locations Management
+            .addPermission(keys.Locations.Management, await this.translateService.translateAsync('@location-management:locations.permissions.locations.title'), await this.translateService.translateAsync('@location-management:locations.permissions.locations.description'))
+            .addChild(keys.Locations.View, await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.view.title'), await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.view.description'))
+            .addChild(keys.Locations.Create, await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.create.title'), await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.create.description'))
+            .addChild(keys.Locations.Edit, await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.edit.title'), await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.edit.description'))
+            .addChild(keys.Locations.Delete, await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.delete.title'), await this.translateService.translateAsync('@location-management:locations.permissions.locations.actions.delete.description'))
+            .endPermission()
+            // Location Types Management
+            .addPermission(keys.LocationTypes.Management, await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.title'), await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.description'))
+            .addChild(keys.LocationTypes.View, await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.view.title'), await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.view.description'))
+            .addChild(keys.LocationTypes.Create, await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.create.title'), await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.create.description'))
+            .addChild(keys.LocationTypes.Edit, await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.edit.title'), await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.edit.description'))
+            .addChild(keys.LocationTypes.Delete, await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.delete.title'), await this.translateService.translateAsync('@location-management:location-types.permissions.location-types.actions.delete.description'))
+            .endPermission()
+            // Location Roles Management
+            .addPermission(keys.LocationRoles.Management, await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.title'), await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.description'))
+            .addChild(keys.LocationRoles.View, await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.view.title'), await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.view.description'))
+            .addChild(keys.LocationRoles.Create, await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.create.title'), await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.create.description'))
+            .addChild(keys.LocationRoles.Edit, await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.edit.title'), await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.edit.description'))
+            .addChild(keys.LocationRoles.Delete, await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.delete.title'), await this.translateService.translateAsync('@location-management:location-roles.permissions.location-roles.actions.delete.description'))
+            .endPermission()
+            // Geographic Regions Management
+            .addPermission(keys.GeographicRegions.Management, await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.title'), await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.description'))
+            .addChild(keys.GeographicRegions.View, await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.view.title'), await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.view.description'))
+            .addChild(keys.GeographicRegions.Create, await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.create.title'), await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.create.description'))
+            .addChild(keys.GeographicRegions.Edit, await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.edit.title'), await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.edit.description'))
+            .addChild(keys.GeographicRegions.Delete, await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.delete.title'), await this.translateService.translateAsync('@location-management:geographic-regions.permissions.geographic-regions.actions.delete.description'))
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementPermissionDefinitionProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Menu Provider   ----
+class AXMLocationManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        // Ensure Contacts root menu exists before adding items (avoids dependency on provider order)
+        const contactsMenu = context.find(AXPCommonMenuKeys.Contacts);
+        if (!contactsMenu.exists) {
+            context.addItems([
+                {
+                    name: AXPCommonMenuKeys.Contacts,
+                    priority: 8010,
+                    text: '@general:menus.contacts.title',
+                    icon: 'fa-light fa-address-book',
+                    type: 'menu',
+                    children: [],
+                },
+            ]);
+        }
+        // Add Locations entity list under Contact root menu
+        context.find(AXPCommonMenuKeys.Contacts).addItems([
+            {
+                name: AXPLocationManagementMenuKeys.Locations,
+                text: RootConfig.entities.location.titlePlural,
+                path: this.entityService.createPath(module.name, RootConfig.entities.location.name),
+                icon: RootConfig.entities.location.icon,
+                priority: 40,
+                policy: {
+                    features: [module.name],
+                    permissions: [AXMLocationManagementPermissionsKeys.LocationManagement.Locations.View],
+                },
+            },
+        ]);
+        // Add LocationTypes and GeographicRegions under Configuration/Region
+        context.find(AXPCommonMenuKeys.Region).addItems([
+            {
+                name: AXPLocationManagementMenuKeys.LocationTypes,
+                text: '@location-management:location-types.menus.location-types.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.locationType.name),
+                icon: RootConfig.entities.locationType.icon,
+                priority: 1,
+                policy: {
+                    features: [module.name],
+                    permissions: [AXMLocationManagementPermissionsKeys.LocationManagement.LocationTypes.View],
+                },
+            },
+            {
+                name: AXPLocationManagementMenuKeys.LocationRoles,
+                text: '@location-management:location-roles.menus.location-roles.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.locationRole.name),
+                icon: RootConfig.entities.locationRole.icon,
+                priority: 2,
+                policy: {
+                    features: [module.name],
+                    permissions: [AXMLocationManagementPermissionsKeys.LocationManagement.LocationRoles.View],
+                },
+            },
+            {
+                name: AXPLocationManagementMenuKeys.GeographicRegions,
+                text: '@location-management:geographic-regions.menus.geographic-regions.title',
+                path: this.entityService.createPath(module.name, RootConfig.entities.geographicRegion.name),
+                icon: RootConfig.entities.geographicRegion.icon,
+                priority: 3,
+                policy: {
+                    features: [module.name],
+                    permissions: [AXMLocationManagementPermissionsKeys.LocationManagement.GeographicRegions.View],
+                },
+            },
+        ]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementMenuProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementMenuProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementMenuProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMLocationManagementEntityProvider {
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == RootConfig.module.name) {
+            switch (entityName) {
+                case RootConfig.entities.location.name:
+                    return (await import('@acorex-platform/module-location-management-client/contracts')).locationFactory();
+                case RootConfig.entities.locationType.name:
+                    return (await import('@acorex-platform/module-location-management-client/contracts')).locationTypeFactory();
+                case RootConfig.entities.locationRole.name:
+                    return (await import('@acorex-platform/module-location-management-client/contracts')).locationRoleFactory();
+                case RootConfig.entities.geographicRegion.name:
+                    return (await import('@acorex-platform/module-location-management-client/contracts')).geographicRegionFactory();
+                case RootConfig.entities.locationAssignment.name:
+                    return (await import('@acorex-platform/module-location-management-client/contracts')).locationAssignmentFactory();
+            }
+        }
+        return null;
+    }
+    async list() {
+        const m = RootConfig.module.name;
+        return Promise.resolve(Object.values(RootConfig.entities).map((e) => ({ name: e.name, module: m })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMSettingProvider {
+    async provide(context) {
+        // context
+        //   // Add Form Template Group
+        //   .addGroup('form-template', 'Form Template', 'Settings related to form templates.', RootConfig.module.icon)
+        //   // Start Interface Section
+        //   .addSection('interface', 'UI Interface', 'Customize the user interface for forms.')
+        //   .addSetting({
+        //     key: 'history-panel',
+        //     title: 'Show History Panel',
+        //     scope: 'U',
+        //     isInherited: true,
+        //     defaultValue: false,
+        //     widget: {
+        //       type: AXPWidgetsCatalog.toggle,
+        //     },
+        //     description: 'Enable or disable the history panel for forms.',
+        //     validationRules: [
+        //       {
+        //         rule: 'required',
+        //       },
+        //     ],
+        //   })
+        //   .endSection()
+        //   .endGroup();
+    }
+}
+
+class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            {
+                id: 'create-location-role',
+                group: 'command',
+                title: RootConfig.entities.locationRole.title,
+                icon: RootConfig.entities.locationRole.icon,
+                description: RootConfig.entities.locationRole.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.locationRole.name}`, {
+                        name: RootConfig.entities.locationRole.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.locationRole.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-location-type',
+                group: 'command',
+                title: RootConfig.entities.locationType.title,
+                icon: RootConfig.entities.locationType.icon,
+                description: RootConfig.entities.locationType.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.locationType.name}`, {
+                        name: RootConfig.entities.locationType.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.locationType.title,
+                    }),
+                },
+            },
+            {
+                id: 'create-geographic-region',
+                group: 'command',
+                title: RootConfig.entities.geographicRegion.title,
+                icon: RootConfig.entities.geographicRegion.icon,
+                description: RootConfig.entities.geographicRegion.titlePlural,
+                command: {
+                    name: 'Entity:Create',
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`, {
+                        name: RootConfig.entities.geographicRegion.name,
+                        module: RootConfig.module.name,
+                        title: RootConfig.entities.geographicRegion.title,
+                    }),
+                },
+            },
+        ];
+    }
+}
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Feature Definition Provider   ----
+/**
+ * Location Management Feature Definition Provider.
+ * Provides feature definitions for the Location Management module.
+ */
+class AXMLocationManagementFeatureDefinitionProvider {
+    async provide(context) {
+        // Management feature removed - module name is used directly as feature key
+    }
+}
+//#endregion
+
+class AXMGeographicRegionDataSourceDefinition {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.geographicRegionService = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.geographicRegion.name)
+            .data();
+        //#region ---- Country ----
+        this.countries = {
+            name: AXMLocationManagementDataSourceKeys.Countries,
+            title: 'Countries',
+            columns: [
+                {
+                    name: 'code',
+                    title: 'Code',
+                    type: 'string',
+                    datatype: 'string',
+                },
+                {
+                    name: 'title',
+                    title: 'Title',
+                    type: 'string',
+                    datatype: 'string',
+                },
+            ],
+            filters: [],
+            textField: { name: 'title', title: 'Title' },
+            valueField: { name: 'id', title: 'Id' },
+            samples: [
+                { id: 'US', title: 'United States' },
+                { id: 'CA', title: 'Canada' },
+                { id: 'GB', title: 'United Kingdom' },
+                { id: 'AU', title: 'Australia' },
+                { id: 'NZ', title: 'New Zealand' },
+                { id: 'ZA', title: 'South Africa' },
+                { id: 'IN', title: 'India' },
+            ],
+            source: () => {
+                return new AXDataSource({
+                    pageSize: 50,
+                    key: 'id',
+                    load: async (e) => {
+                        const result = await this.geographicRegionService.query({
+                            ...e,
+                            filter: { field: 'type.code', operator: { type: 'equal' }, value: 'country' },
+                            sort: [{ field: 'title', dir: 'asc' }],
+                        });
+                        return {
+                            items: result.items,
+                            total: result.total,
+                        };
+                    },
+                    byKey: async (key) => {
+                        const item = await this.geographicRegionService.byKey(key);
+                        return item;
+                    },
+                });
+            },
+        };
+        //#endregion
+        //#region ---- Provinces (States) ----
+        this.provinces = {
+            name: AXMLocationManagementDataSourceKeys.Provinces,
+            title: 'Provinces',
+            columns: [
+                {
+                    name: 'code',
+                    title: 'Code',
+                    type: 'string',
+                    datatype: 'string',
+                },
+                {
+                    name: 'title',
+                    title: 'Title',
+                    type: 'string',
+                    datatype: 'string',
+                },
+            ],
+            filters: [
+                {
+                    field: 'parentId',
+                    title: 'Country',
+                    operator: { type: 'equal' },
+                    widget: {
+                        type: AXPWidgetsCatalog.selectFilter,
+                        options: {
+                            dataSource: AXMLocationManagementDataSourceKeys.Countries,
+                            valueField: 'id',
+                            textField: 'title',
+                        },
+                    },
+                    filterType: { advance: true, inline: true },
+                },
+            ],
+            textField: { name: 'title', title: 'Title' },
+            valueField: { name: 'id', title: 'Id' },
+            source: () => {
+                return new AXDataSource({
+                    pageSize: 50,
+                    key: 'id',
+                    load: async (e) => {
+                        console.log('[provinces datasource] load query:', { filter: e?.filter, take: e?.take, skip: e?.skip });
+                        const typeFilter = { field: 'type.code', operator: { type: 'equal' }, value: 'state' };
+                        const extraFilters = e?.filter?.filters ?? (e?.filter ? [e.filter] : []);
+                        const filter = extraFilters.length > 0
+                            ? { logic: 'and', filters: [typeFilter, ...extraFilters] }
+                            : typeFilter;
+                        console.log('[provinces datasource] extraFilters:', extraFilters, 'final filter:', filter);
+                        const result = await this.geographicRegionService.query({
+                            ...e,
+                            filter,
+                            sort: [{ field: 'title', dir: 'asc' }],
+                        });
+                        console.log('[provinces datasource] result:', result.items?.length, result.total);
+                        return {
+                            items: result.items,
+                            total: result.total,
+                        };
+                    },
+                    byKey: async (key) => {
+                        const item = await this.geographicRegionService.byKey(key);
+                        return item;
+                    },
+                });
+            },
+        };
+        //#endregion
+        //#region ---- Cities ----
+        this.cities = {
+            name: AXMLocationManagementDataSourceKeys.Cities,
+            title: 'Cities',
+            columns: [
+                {
+                    name: 'code',
+                    title: 'Code',
+                    type: 'string',
+                    datatype: 'string',
+                },
+                {
+                    name: 'title',
+                    title: 'Title',
+                    type: 'string',
+                    datatype: 'string',
+                },
+            ],
+            filters: [
+                {
+                    field: 'parentId',
+                    title: 'Province',
+                    operator: { type: 'equal' },
+                    widget: {
+                        type: AXPWidgetsCatalog.selectFilter,
+                        options: {
+                            dataSource: AXMLocationManagementDataSourceKeys.Provinces,
+                            valueField: 'id',
+                            textField: 'title',
+                        },
+                    },
+                    filterType: { advance: true, inline: true },
+                },
+            ],
+            textField: { name: 'title', title: 'Title' },
+            valueField: { name: 'id', title: 'Id' },
+            source: () => {
+                return new AXDataSource({
+                    pageSize: 50,
+                    key: 'id',
+                    load: async (e) => {
+                        console.log('[cities datasource] load query:', { filter: e?.filter, take: e?.take, skip: e?.skip });
+                        const typeFilter = { field: 'type.code', operator: { type: 'equal' }, value: 'city' };
+                        const extraFilters = e?.filter?.filters ?? (e?.filter ? [e.filter] : []);
+                        const filter = extraFilters.length > 0
+                            ? { logic: 'and', filters: [typeFilter, ...extraFilters] }
+                            : typeFilter;
+                        console.log('[cities datasource] extraFilters:', extraFilters, 'final filter:', filter);
+                        const result = await this.geographicRegionService.query({
+                            ...e,
+                            filter,
+                            sort: [{ field: 'title', dir: 'asc' }],
+                        });
+                        console.log('[cities datasource] result:', result.items?.length, result.total);
+                        return {
+                            items: result.items,
+                            total: result.total,
+                        };
+                    },
+                    byKey: async (key) => {
+                        const item = await this.geographicRegionService.byKey(key);
+                        return item;
+                    },
+                });
+            },
+        };
+    }
+    //#endregion
+    async items() {
+        return [this.countries, this.provinces, this.cities];
+    }
+}
+
+//#region ----   LocationAssignment nested hydration   ----
+const LOCATION_ASSIGNMENT_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.locationAssignment.name}`;
+const LOCATION_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.location.name}`;
+const PERSON_ENTITY = 'PersonCore.Person';
+/**
+ * Hydrates nested `location` and `person` on LocationAssignment rows so consumers
+ * (e.g. party location lists) receive computed fields such as `fullAddress` and `fullName`.
+ */
+const locationAssignmentLocationHydrateMiddleware = {
+    target: { ops: ['getOne', 'getAll', 'query'], order: 13 },
+    execute: async (ctx, next) => {
+        const backend = inject(AXP_ENTITY_STORAGE_BACKEND);
+        await next();
+        if (ctx.entityName !== LOCATION_ASSIGNMENT_ENTITY) {
+            return;
+        }
+        try {
+            const rows = Array.isArray(ctx.result)
+                ? ctx.result
+                : Array.isArray(ctx.result?.items)
+                    ? (ctx.result.items ?? [])
+                    : ctx.result
+                        ? [ctx.result]
+                        : [];
+            if (!rows.length) {
+                return;
+            }
+            const locationIds = Array.from(new Set(rows.map((row) => get(row, 'locationId')).filter((id) => id != null)));
+            const personIds = Array.from(new Set(rows.map((row) => get(row, 'personId')).filter((id) => id != null)));
+            const locationMap = new Map();
+            if (locationIds.length) {
+                const locationResponse = await backend.query(LOCATION_ENTITY, {
+                    skip: 0,
+                    take: locationIds.length,
+                    filter: { field: 'id', operator: { type: 'in' }, value: locationIds },
+                });
+                for (const item of locationResponse?.items ?? []) {
+                    const record = item;
+                    locationMap.set(get(record, 'id'), record);
+                }
+            }
+            const personMap = new Map();
+            if (personIds.length) {
+                const personResponse = await backend.query(PERSON_ENTITY, {
+                    skip: 0,
+                    take: personIds.length,
+                    filter: { field: 'id', operator: { type: 'in' }, value: personIds },
+                });
+                for (const item of personResponse?.items ?? []) {
+                    const record = item;
+                    personMap.set(get(record, 'id'), record);
+                }
+            }
+            for (const row of rows) {
+                const locationId = get(row, 'locationId');
+                if (locationId != null) {
+                    const location = locationMap.get(locationId);
+                    if (location) {
+                        set(row, 'location', buildLocationAssignmentLocationSnapshot(location, locationId));
+                    }
+                }
+                const personId = get(row, 'personId');
+                if (personId != null) {
+                    const person = personMap.get(personId);
+                    if (person) {
+                        set(row, 'person', buildLocationAssignmentPersonSnapshot(person, personId));
+                    }
+                }
+            }
+        }
+        catch {
+            // swallow to avoid breaking main flow
+        }
+    },
+};
+//#endregion
+
+const AXPAddressWidget = {
+    name: 'address-editor',
+    title: '@platform-layout-widgets:widgets.address-editor.title',
+    description: '@platform-layout-widgets:widgets.address-editor.description',
+    categories: AXP_WIDGETS_EDITOR_CATEGORY,
+    subCategory: AXP_WIDGETS_EDITOR_SUB_COMPOSITE,
+    groups: [AXPWidgetGroupEnum.FormElement],
+    icon: 'fa-light fa-location-dot',
+    defaultFilterWidgetName: 'string-filter',
+    type: 'editor',
+    properties: [
+        AXP_NAME_PROPERTY,
+        AXP_DATA_PATH_PROPERTY,
+        createSelectProperty({
+            name: 'mode',
+            title: 'Mode',
+            group: AXP_BEHAVIOR_PROPERTY_GROUP,
+            dataSource: [
+                { id: 'simple', title: 'Single line' },
+                { id: 'popup', title: 'Popup editor' },
+                { id: 'expandable', title: 'Expandable panel' },
+            ],
+            defaultValue: { id: 'simple', title: 'Single line' },
+            path: 'options.mode',
+        }),
+        createBooleanProperty({
+            name: 'hasLabel',
+            title: 'Has Label',
+            group: AXP_BEHAVIOR_PROPERTY_GROUP,
+            defaultValue: false,
+            path: 'options.hasLabel',
+        }),
+        createBooleanProperty({
+            name: 'hasMap',
+            title: 'Has Map',
+            group: AXP_BEHAVIOR_PROPERTY_GROUP,
+            defaultValue: true,
+            path: 'options.hasMap',
+        }),
+        AXP_DISABLED_PROPERTY,
+        AXP_HAS_LABEL_PROPERTY,
+        AXP_PLACEHOLDER_PROPERTY,
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return addressWidgetView_component; }).then((c) => c.AXPAddressWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return addressWidgetEdit_component; }).then((c) => c.AXPAddressWidgetEditComponent),
+        },
+        column: {
+            component: () => Promise.resolve().then(function () { return addressWidgetColumn_component; }).then((c) => c.AXPAddressWidgetColumnComponent),
+        },
+        designer: {
+            component: () => Promise.resolve().then(function () { return addressWidgetEdit_component; }).then((c) => c.AXPAddressWidgetEditComponent),
+        },
+    },
+};
+
+//#endregion
+
+const TENANT_ORGANIZATION_ADDRESS_SETTINGS = {
+    street1: 'OrganizationManagement:Setting:Organization.Street1',
+    street2: 'OrganizationManagement:Setting:Organization.Street2',
+    countryId: 'OrganizationManagement:Setting:Organization.CountryId',
+    stateId: 'OrganizationManagement:Setting:Organization.StateId',
+    cityId: 'OrganizationManagement:Setting:Organization.CityId',
+    postalCode: 'OrganizationManagement:Setting:Organization.PostalCode',
+};
+const GEOGRAPHIC_REGION_ENTITY = 'LocationManagement.GeographicRegion';
+//#region ----   Service   ----
+class AXPAddressWidgetService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.translationService = inject(AXTranslationService);
+        this.settingsService = inject(AXPSettingsService);
+        this.entityService = inject(AXPEntityService);
+        this.geographicDefaultsCache = null;
+        this.geographicTitleCache = new Map();
+        this.settingsService.onChanged.subscribe((event) => {
+            const settingKeys = Object.values(TENANT_ORGANIZATION_ADDRESS_SETTINGS);
+            if (event.keys.some((key) => settingKeys.includes(key))) {
+                this.invalidateGeographicDefaultsCache();
+            }
+        });
+    }
+    //#endregion
+    //#region ----   Shared address form layout (dialog + inline renderer)   ----
+    /**
+     * Builds the address form content (street1, street2, country, state, city, postalCode, label, map).
+     * Used by both the dialog and the expandable inline layout via create().flex().build().
+     */
+    buildAddressFormContent(flex, options) {
+        const { hasLabel, labelEntity, hasMap, addressData } = options;
+        const showLabel = !!hasLabel && !!labelEntity;
+        flex.mode('edit').setDirection('column').setGap('12px');
+        //#region ----   Row 1: label + show map   ----
+        if (showLabel || hasMap) {
+            flex.grid((metaRow) => {
+                metaRow.setColumns(12).setGap('12px');
+                if (showLabel) {
+                    metaRow.formField('@location-management:locations.entities.location.fields.label', (field) => {
+                        field.path('labelId');
+                        field.layout(3);
+                        field.customWidget('lookup-editor', {
+                            entity: labelEntity,
+                            look: 'select',
+                            textField: 'title',
+                            valueField: 'id',
+                            hasClearButton: true,
+                            allowCreate: 'quick',
+                            create: {
+                                enable: true,
+                            },
+                            expose: [
+                                { source: 'id', target: 'label.id' },
+                                { source: 'title', target: 'label.title' },
+                            ],
+                            validations: [{ rule: 'required', message: '@general:validation.messages.required' }],
+                        });
+                    });
+                }
+                if (hasMap) {
+                    metaRow.formField('@location-management:locations.entities.location.fields.show-map', (field) => {
+                        field.path('showMap');
+                        field.layout(3);
+                        field.toggleSwitch({
+                            defaultValue: !!(addressData?.coordinates),
+                        });
+                    });
+                }
+            });
+        }
+        //#endregion
+        //#region ----   Row 2: street address + address line 2   ----
+        flex.grid((streetRow) => {
+            streetRow.setColumns(12).setGap('12px');
+            streetRow
+                .formField('@location-management:locations.entities.location.fields.street1', (field) => {
+                field.path('street1');
+                field.layout(6);
+                field.textBox({
+                    validations: [{ rule: 'required', message: '@general:validation.messages.required' }],
+                });
+            })
+                .formField('@location-management:locations.entities.location.fields.street2', (field) => {
+                field.path('street2');
+                field.layout(6);
+                field.textBox({});
+            });
+        });
+        //#endregion
+        //#region ----   Row 3: postal code + country + state + city   ----
+        flex.grid((geoRow) => {
+            geoRow.setColumns(12).setGap('12px');
+            geoRow
+                .formField('@location-management:locations.entities.location.fields.postal-code', (field) => {
+                field.path('postalCode');
+                field.layout(3);
+                field.textBox({ placeholder: 'Enter postal code' });
+            })
+                .formField('@location-management:locations.entities.location.fields.country', (field) => {
+                field.path('countryId');
+                field.layout(3);
+                field.customWidget('lookup-editor', {
+                    entity: 'LocationManagement.GeographicRegion',
+                    look: 'select',
+                    textField: 'title',
+                    valueField: 'id',
+                    hasClearButton: true,
+                    allowCreate: 'quick',
+                    create: {
+                        enable: true,
+                    },
+                    expose: [
+                        { source: 'id', target: 'country.id' },
+                        { source: 'title', target: 'country.title' },
+                    ],
+                    filter: {
+                        logic: 'and',
+                        filters: [{ field: 'type.code', operator: { type: 'equal' }, value: 'country' }],
+                    },
+                });
+            })
+                .formField('@location-management:locations.entities.location.fields.state', (field) => {
+                field.path('stateId');
+                field.layout(3);
+                field.customWidget('lookup-editor', {
+                    entity: 'LocationManagement.GeographicRegion',
+                    look: 'select',
+                    textField: 'title',
+                    valueField: 'id',
+                    hasClearButton: true,
+                    allowCreate: 'quick',
+                    disabled: '{{ !context.eval("countryId") }}',
+                    create: {
+                        enable: true,
+                        context: {
+                            parentId: '{{ context.eval("countryId") }}',
+                            type: { code: 'state' },
+                        },
+                    },
+                    expose: [
+                        { source: 'id', target: 'state.id' },
+                        { source: 'title', target: 'state.title' },
+                    ],
+                    filter: {
+                        logic: 'and',
+                        filters: [
+                            { field: 'parentId', operator: { type: 'equal' }, value: '{{ context.eval("countryId") }}' },
+                            { field: 'type.code', operator: { type: 'equal' }, value: 'state' },
+                        ],
+                    },
+                    triggers: [
+                        {
+                            event: "{{ events.context('countryId') }}",
+                            action: "{{ widget.setValue(null); context.set('state.title', null); context.set('cityId', null); context.set('city.id', null); context.set('city.title', null); widget.refresh(); }}",
+                        },
+                    ],
+                });
+            })
+                .formField('@location-management:locations.entities.location.fields.city', (field) => {
+                field.path('cityId');
+                field.layout(3);
+                field.customWidget('lookup-editor', {
+                    entity: 'LocationManagement.GeographicRegion',
+                    look: 'select',
+                    textField: 'title',
+                    valueField: 'id',
+                    hasClearButton: true,
+                    allowCreate: 'quick',
+                    disabled: '{{ !context.eval("stateId") }}',
+                    create: {
+                        enable: true,
+                        context: {
+                            parentId: '{{ context.eval("stateId") }}',
+                            type: { code: 'city' },
+                        },
+                    },
+                    expose: [
+                        { source: 'id', target: 'city.id' },
+                        { source: 'title', target: 'city.title' },
+                    ],
+                    filter: {
+                        logic: 'and',
+                        filters: [
+                            { field: 'parentId', operator: { type: 'equal' }, value: '{{ context.eval("stateId") }}' },
+                            { field: 'type.code', operator: { type: 'equal' }, value: 'city' },
+                        ],
+                    },
+                    triggers: [
+                        {
+                            event: "{{ events.context('stateId') }}",
+                            action: "{{ widget.setValue(null); context.set('city.title', null); widget.refresh(); }}",
+                        },
+                        {
+                            event: "{{ events.context('countryId') }}",
+                            action: "{{ widget.setValue(null); context.set('city.title', null); widget.refresh(); }}",
+                        },
+                    ],
+                });
+            });
+        });
+        //#endregion
+        //#region ----   Map picker (when show map is enabled)   ----
+        if (hasMap) {
+            flex.grid((mapRow) => {
+                mapRow.setColumns(12).setGap('12px');
+                mapRow.formField('@location-management:locations.entities.location.fields.coordinates', (field) => {
+                    field.path('coordinates');
+                    field.layout(12);
+                    field.visible('{{ context.eval("showMap") }}');
+                    field.customWidget('map', { hasDraw: true, maxPolygon: 0 });
+                });
+            });
+        }
+        //#endregion
+    }
+    /**
+     * Returns the address form layout node using layoutBuilder.create().flex().build() for use in axp-layout-renderer.
+     */
+    getAddressFormLayout(options) {
+        return this.layoutBuilder
+            .create()
+            .flex((flex) => this.buildAddressFormContent(flex, options))
+            .build();
+    }
+    //#endregion
+    //#region ----   Geographic Defaults Methods   ----
+    /** Loads geographic defaults from tenant organization address settings. */
+    async getGeographicDefaults() {
+        if (!this.geographicDefaultsCache) {
+            this.geographicDefaultsCache = this.loadGeographicDefaultsFromSettings();
+        }
+        return this.geographicDefaultsCache;
+    }
+    async loadGeographicDefaultsFromSettings() {
+        const tenantScope = this.settingsService.scope(AXPPlatformScope.Tenant);
+        const [countryId, stateId, cityId, street1, street2, postalCode] = await Promise.all([
+            tenantScope.get(TENANT_ORGANIZATION_ADDRESS_SETTINGS.countryId),
+            tenantScope.get(TENANT_ORGANIZATION_ADDRESS_SETTINGS.stateId),
+            tenantScope.get(TENANT_ORGANIZATION_ADDRESS_SETTINGS.cityId),
+            tenantScope.get(TENANT_ORGANIZATION_ADDRESS_SETTINGS.street1),
+            tenantScope.get(TENANT_ORGANIZATION_ADDRESS_SETTINGS.street2),
+            tenantScope.get(TENANT_ORGANIZATION_ADDRESS_SETTINGS.postalCode),
+        ]);
+        const resolvedCountry = this.resolveSettingLookupSnapshot(countryId);
+        const resolvedState = this.resolveSettingLookupSnapshot(stateId);
+        const resolvedCity = this.resolveSettingLookupSnapshot(cityId);
+        const resolvedStreet1 = defaultTo(street1, '').trim();
+        const resolvedStreet2 = defaultTo(street2, '').trim();
+        const resolvedPostalCode = defaultTo(postalCode, '').trim();
+        if (isEmpty(resolvedCountry?.id) &&
+            isEmpty(resolvedState?.id) &&
+            isEmpty(resolvedCity?.id) &&
+            isEmpty(resolvedStreet1) &&
+            isEmpty(resolvedStreet2) &&
+            isEmpty(resolvedPostalCode)) {
+            return null;
+        }
+        return {
+            street1: resolvedStreet1 || undefined,
+            street2: resolvedStreet2 || undefined,
+            postalCode: resolvedPostalCode || undefined,
+            countryId: resolvedCountry?.id,
+            stateId: resolvedState?.id,
+            cityId: resolvedCity?.id,
+            country: resolvedCountry,
+            state: resolvedState,
+            city: resolvedCity,
+        };
+    }
+    /** Clears cached defaults (e.g. after tenant settings change). */
+    invalidateGeographicDefaultsCache() {
+        this.geographicDefaultsCache = null;
+    }
+    /**
+     * Applies tenant/platform geographic defaults to empty address fields only.
+     * Returns whether any field was updated.
+     */
+    async applyGeographicDefaultsIfNeeded(value, options) {
+        if (options?.enabled === false) {
+            return { value, applied: false };
+        }
+        const defaults = await this.getGeographicDefaults();
+        if (!defaults) {
+            return { value, applied: false };
+        }
+        const merged = this.mergeGeographicDefaults(value, defaults);
+        const enriched = await this.enrichGeographicLookupTitles(merged);
+        const applied = !isEqual(this.snapshotGeographicFields(value), this.snapshotGeographicFields(enriched));
+        return { value: enriched, applied };
+    }
+    /** Merges defaults into empty country/state/city (and optional street/postal) fields. */
+    mergeGeographicDefaults(value, defaults) {
+        const result = { ...value };
+        if (this.isLookupEmpty(result.country) && defaults.country?.id) {
+            result.country = defaults.country;
+        }
+        if (this.isLookupEmpty(result.state) && defaults.state?.id) {
+            result.state = defaults.state;
+        }
+        if (this.isLookupEmpty(result.city) && defaults.city?.id) {
+            result.city = defaults.city;
+        }
+        if (!result.street1?.trim() && defaults.street1?.trim()) {
+            result.street1 = defaults.street1;
+        }
+        if (!result.street2?.trim() && defaults.street2?.trim()) {
+            result.street2 = defaults.street2;
+        }
+        if (!result.postalCode?.trim() && defaults.postalCode?.trim()) {
+            result.postalCode = defaults.postalCode;
+        }
+        return result;
+    }
+    /** Ensures country/state/city snapshots include titles required for formatted address text. */
+    async enrichGeographicLookupTitles(value) {
+        const [country, state, city] = await Promise.all([
+            this.enrichLookupField(value.country),
+            this.enrichLookupField(value.state),
+            this.enrichLookupField(value.city),
+        ]);
+        if (country === value.country && state === value.state && city === value.city) {
+            return value;
+        }
+        return { ...value, country, state, city };
+    }
+    //#endregion
+    //#region ----   Geographic Cascade Methods   ----
+    /**
+     * Builds layout context with flat lookup ids (countryId/stateId/cityId/labelId) required for cascade triggers.
+     * Same pattern as LocationManagement.Location entity fields.
+     */
+    buildAddressFormContext(addressData, options) {
+        return {
+            ...addressData,
+            countryId: addressData.country?.id,
+            stateId: addressData.state?.id,
+            cityId: addressData.city?.id,
+            labelId: addressData.label?.id,
+            showMap: (options?.hasMap ?? false) && !!addressData.coordinates,
+        };
+    }
+    /**
+     * Clears dependent geographic fields when a parent selection changes.
+     * Mirrors Location entity cascade: state depends on country, city depends on state.
+     */
+    applyGeographicCascade(previous, next) {
+        const result = { ...next };
+        const previousCountryId = previous.countryId ?? previous.country?.id;
+        const nextCountryId = result.countryId ?? result.country?.id;
+        const previousStateId = previous.stateId ?? previous.state?.id;
+        const nextStateId = result.stateId ?? result.state?.id;
+        if (previousCountryId !== nextCountryId) {
+            result.state = undefined;
+            result.city = undefined;
+            result.stateId = undefined;
+            result.cityId = undefined;
+        }
+        else if (previousStateId !== nextStateId) {
+            result.city = undefined;
+            result.cityId = undefined;
+        }
+        return result;
+    }
+    //#endregion
+    //#region ----   Address Formatting Methods   ----
+    /**
+     * Formats address data into full address string
+     * Format: [street1], [street2], [country] - [state], [city], [postalCode]
+     * Uses titles from exposed fields, excludes coordinates
+     */
+    formatAddress(data) {
+        return formatAddressData(data);
+    }
+    /**
+     * Collapse header parts: label title (semibold in template) + full address.
+     */
+    async resolveCollapsibleHeader(value, options) {
+        const enriched = await this.enrichGeographicLookupTitles(value);
+        const full = (enriched.full?.trim() || this.formatAddress(enriched)).trim();
+        const addressText = full !== '' ? full : options.placeholder;
+        const labelText = enriched.label?.title?.trim() || null;
+        return { labelText, addressText };
+    }
+    //#endregion
+    //#region ----   Dialog & UI Methods   ----
+    /**
+     * Shows address details popup dialog using the shared address form layout.
+     */
+    async showAddressDetailsPopup(addressData, options = {}) {
+        const { hasMap = true, hasLabel, labelEntity, useGeographicDefaults = true } = options;
+        const { value: addressWithDefaults } = await this.applyGeographicDefaultsIfNeeded(addressData, {
+            enabled: useGeographicDefaults,
+        });
+        const initialContext = this.buildAddressFormContext(addressWithDefaults, { hasMap });
+        const dialogTitle = await this.translationService.translateAsync('@general:terms.common.address');
+        const ref = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(dialogTitle)
+                .setSize('lg')
+                .setContext(initialContext)
+                .content((layoutBuilder) => {
+                layoutBuilder.flex((flex) => this.buildAddressFormContent(flex, {
+                    hasLabel,
+                    labelEntity,
+                    hasMap,
+                    addressData: addressWithDefaults,
+                }));
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.cancel.title').submit('@general:actions.apply.title');
+            });
+        })
+            .show();
+        if (ref.action() === 'cancel') {
+            ref.close();
+            return null;
+        }
+        const result = this.applyGeographicCascade(initialContext, this.normalizeAddressData(ref.context()));
+        ref.close();
+        return result;
+    }
+    //#endregion
+    //#region ----   Data Normalization Methods   ----
+    /**
+     * Normalizes address data from various input formats
+     */
+    normalizeAddressData(value) {
+        if (typeof value === 'object' && value !== null) {
+            const contextValue = value;
+            return {
+                street1: contextValue.street1 ?? '',
+                street2: contextValue.street2,
+                country: contextValue.country,
+                state: contextValue.state,
+                city: contextValue.city,
+                postalCode: contextValue.postalCode,
+                coordinates: contextValue.coordinates,
+                full: contextValue.full ?? this.formatAddress(contextValue),
+                label: this.resolveLabel(contextValue),
+            };
+        }
+        // Simple string format
+        return {
+            street1: '',
+            street2: '',
+            country: undefined,
+            state: undefined,
+            city: undefined,
+            postalCode: '',
+            coordinates: undefined,
+            full: value?.toString() || '',
+            label: undefined,
+        };
+    }
+    /** Resolves persisted label snapshot from lookup expose or transient labelId. */
+    resolveLabel(value) {
+        const exposed = value.label;
+        if (exposed?.id) {
+            return { id: exposed.id, title: exposed.title };
+        }
+        if (value.labelId) {
+            return { id: value.labelId, title: exposed?.title };
+        }
+        return undefined;
+    }
+    isLookupEmpty(value) {
+        return isNil(value?.id) || value.id === '';
+    }
+    snapshotGeographicFields(value) {
+        return {
+            street1: value.street1,
+            street2: value.street2,
+            postalCode: value.postalCode,
+            country: value.country,
+            state: value.state,
+            city: value.city,
+        };
+    }
+    resolveSettingLookupSnapshot(value) {
+        if (isNil(value) || value === '') {
+            return undefined;
+        }
+        if (typeof value === 'object') {
+            const record = value;
+            const id = extractValue(record.id ?? value);
+            const title = extractValue(record.title);
+            if (!id?.trim()) {
+                return undefined;
+            }
+            return {
+                id: id.trim(),
+                title: title?.trim() || undefined,
+            };
+        }
+        const id = extractValue(value);
+        return id?.trim() ? { id: id.trim() } : undefined;
+    }
+    async enrichLookupField(field) {
+        if (!field?.id || field.title?.trim()) {
+            return field;
+        }
+        const title = await this.resolveGeographicRegionTitle(field.id);
+        return title ? { id: field.id, title } : field;
+    }
+    async resolveGeographicRegionTitle(id) {
+        if (this.geographicTitleCache.has(id)) {
+            const cached = this.geographicTitleCache.get(id);
+            return cached || undefined;
+        }
+        try {
+            const row = await this.entityService.withEntity(GEOGRAPHIC_REGION_ENTITY).data().byKey(id);
+            const title = extractValue(get(row, 'title'));
+            const normalized = title?.trim() ?? '';
+            this.geographicTitleCache.set(id, normalized);
+            return normalized || undefined;
+        }
+        catch {
+            this.geographicTitleCache.set(id, '');
+            return undefined;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class AXPAddressWidgetEditComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.addressService = inject(AXPAddressWidgetService);
+        /** Collapsible mode: true = panel collapsed (only full address visible), false = expanded (edit button visible) */
+        this.collapsibleCollapsed = signal(true, ...(ngDevMode ? [{ debugName: "collapsibleCollapsed" }] : /* istanbul ignore next */ []));
+        this.collapsibleHeaderLabel = signal(null, ...(ngDevMode ? [{ debugName: "collapsibleHeaderLabel" }] : /* istanbul ignore next */ []));
+        this.collapsibleHeaderAddress = signal('', ...(ngDevMode ? [{ debugName: "collapsibleHeaderAddress" }] : /* istanbul ignore next */ []));
+        /** Bumped on parent discard so the nested layout renderer remounts with reverted context. */
+        this.layoutRendererGeneration = signal(0, ...(ngDevMode ? [{ debugName: "layoutRendererGeneration" }] : /* istanbul ignore next */ []));
+        this.parentContextWasRestored = false;
+        this.geographicDefaultsInitialized = false;
+        this.suppressContextSync = false;
+        /** Blocks ax-collapse from auto-collapsing while a new empty row is opening. */
+        this.blockAutoCollapseUntil = 0;
+        /** Expand new repeater rows so users can enter values without clicking the header again. */
+        this.#expandEmptyAddressEffect = effect(() => {
+            if (this.addressMode() !== 'expandable') {
+                return;
+            }
+            if (this.shouldKeepExpandedForEntry(this.valueAsObject())) {
+                this.collapsibleCollapsed.set(false);
+                this.blockAutoCollapseUntil = Date.now() + 300;
+            }
+        }, ...(ngDevMode ? [{ debugName: "#expandEmptyAddressEffect" }] : /* istanbul ignore next */ []));
+        this.#resetNestedFormOnDiscard = effect(() => {
+            if (this.addressMode() !== 'expandable') {
+                return;
+            }
+            const isRestored = this.contextService.changeEvent().state === 'restored';
+            if (isRestored && !this.parentContextWasRestored) {
+                this.layoutRendererGeneration.update((generation) => generation + 1);
+            }
+            this.parentContextWasRestored = isRestored;
+        }, ...(ngDevMode ? [{ debugName: "#resetNestedFormOnDiscard" }] : /* istanbul ignore next */ []));
+        this.#collapsibleHeaderEffect = effect(() => {
+            const value = this.valueAsObject();
+            this.formattedAddress();
+            const placeholder = this.placeholder();
+            void this.addressService
+                .resolveCollapsibleHeader(value, { placeholder })
+                .then((header) => {
+                this.collapsibleHeaderLabel.set(header.labelText);
+                this.collapsibleHeaderAddress.set(header.addressText);
+            });
+        }, ...(ngDevMode ? [{ debugName: "#collapsibleHeaderEffect" }] : /* istanbul ignore next */ []));
+        this.#applyGeographicDefaultsEffect = effect(() => {
+            if (!this.useGeographicDefaults() || this.geographicDefaultsInitialized) {
+                return;
+            }
+            const value = this.valueAsObject();
+            void this.addressService
+                .applyGeographicDefaultsIfNeeded(value, { enabled: true })
+                .then(({ value: merged, applied }) => {
+                this.geographicDefaultsInitialized = true;
+                if (!applied) {
+                    return;
+                }
+                const normalized = this.addressService.normalizeAddressData(merged);
+                normalized.full = this.addressService.formatAddress(normalized);
+                this.commitAddressValue(normalized);
+            });
+        }, ...(ngDevMode ? [{ debugName: "#applyGeographicDefaultsEffect" }] : /* istanbul ignore next */ []));
+        this.addressMode = computed(() => extractValue(this.options()['mode']) || 'simple', ...(ngDevMode ? [{ debugName: "addressMode" }] : /* istanbul ignore next */ []));
+        this.placeholder = computed(() => this.options()['placeholder'] || 'Enter address...', ...(ngDevMode ? [{ debugName: "placeholder" }] : /* istanbul ignore next */ []));
+        this.labelEntity = computed(() => this.options()['labelEntity'], ...(ngDevMode ? [{ debugName: "labelEntity" }] : /* istanbul ignore next */ []));
+        this.useGeographicDefaults = computed(() => this.options()['useGeographicDefaults'] ?? true, ...(ngDevMode ? [{ debugName: "useGeographicDefaults" }] : /* istanbul ignore next */ []));
+        this.disabled = computed(() => this.options()['disabled'] ?? false, ...(ngDevMode ? [{ debugName: "disabled" }] : /* istanbul ignore next */ []));
+        this.hasLabel = computed(() => this.options()['hasLabel'] ?? false, ...(ngDevMode ? [{ debugName: "hasLabel" }] : /* istanbul ignore next */ []));
+        this.hasMap = computed(() => this.options()['hasMap'] ?? true, ...(ngDevMode ? [{ debugName: "hasMap" }] : /* istanbul ignore next */ []));
+        this.format = computed(() => {
+            if (this.hasLabel() ||
+                this.addressMode() === 'popup' ||
+                this.addressMode() === 'expandable') {
+                return 'object';
+            }
+            return 'string';
+        }, ...(ngDevMode ? [{ debugName: "format" }] : /* istanbul ignore next */ []));
+        this.valueAsObject = computed(() => this.toObject(this.getValue()), ...(ngDevMode ? [{ debugName: "valueAsObject" }] : /* istanbul ignore next */ []));
+        this.formattedAddress = computed(() => {
+            const value = this.valueAsObject();
+            return value.full || this.addressService.formatAddress(value);
+        }, ...(ngDevMode ? [{ debugName: "formattedAddress" }] : /* istanbul ignore next */ []));
+        /** Layout node from create().flex().build() for inline renderer (expandable mode). */
+        this.addressFormLayout = computed(() => this.addressService.getAddressFormLayout({
+            hasLabel: this.hasLabel(),
+            labelEntity: this.labelEntity(),
+            hasMap: this.hasMap(),
+        }), ...(ngDevMode ? [{ debugName: "addressFormLayout" }] : /* istanbul ignore next */ []));
+        /** Context for inline address form (expandable); includes showMap for map toggle. */
+        this.collapsibleFormContext = computed(() => this.addressService.buildAddressFormContext(this.valueAsObject(), {
+            hasMap: this.hasMap(),
+        }), ...(ngDevMode ? [{ debugName: "collapsibleFormContext" }] : /* istanbul ignore next */ []));
+    }
+    /** Expand new repeater rows so users can enter values without clicking the header again. */
+    #expandEmptyAddressEffect;
+    #resetNestedFormOnDiscard;
+    #collapsibleHeaderEffect;
+    #applyGeographicDefaultsEffect;
+    onCollapsibleFormContextChange(ctx) {
+        if (ctx == null || this.suppressContextSync) {
+            return;
+        }
+        const previous = this.addressService.buildAddressFormContext(this.valueAsObject(), {
+            hasMap: this.hasMap(),
+        });
+        void (async () => {
+            const normalized = this.addressService.normalizeAddressData(this.addressService.applyGeographicCascade(previous, ctx));
+            const enriched = await this.addressService.enrichGeographicLookupTitles(normalized);
+            enriched.full = this.addressService.formatAddress(enriched);
+            if (isEqual(enriched, this.valueAsObject())) {
+                return;
+            }
+            this.commitAddressValue(enriched);
+        })();
+    }
+    onCollapsedChange(collapsed) {
+        if (collapsed &&
+            (Date.now() < this.blockAutoCollapseUntil ||
+                this.shouldKeepExpandedForEntry(this.valueAsObject()))) {
+            return;
+        }
+        this.collapsibleCollapsed.set(collapsed);
+    }
+    async handleValueChange(e) {
+        const { name, value, isUserInteraction } = e;
+        if (isUserInteraction) {
+            const newValues = { ...this.valueAsObject(), [name]: value };
+            this.setValue(this.setFormattedValue(newValues));
+        }
+    }
+    async showDetailsPopup() {
+        const currentValue = this.valueAsObject();
+        const result = await this.addressService.showAddressDetailsPopup(currentValue, {
+            hasMap: this.hasMap(),
+            hasLabel: this.hasLabel(),
+            labelEntity: this.labelEntity(),
+            useGeographicDefaults: this.useGeographicDefaults(),
+        });
+        if (result) {
+            result.full = this.addressService.formatAddress(result);
+            this.setValue(this.setFormattedValue(result));
+        }
+    }
+    generateClasses(element) {
+        const isValue = element === 'value';
+        const hasLabel = this.hasLabel();
+        const baseClass = 'col-span-12';
+        if (!hasLabel) {
+            return baseClass;
+        }
+        return {
+            [baseClass]: true,
+            'lg:col-span-7': isValue,
+            'lg:col-span-5': !isValue,
+        };
+    }
+    commitAddressValue(value) {
+        this.suppressContextSync = true;
+        if (this.shouldKeepExpandedForEntry(value)) {
+            this.blockAutoCollapseUntil = Date.now() + 300;
+            this.collapsibleCollapsed.set(false);
+        }
+        this.setValue(this.setFormattedValue(value));
+        window.setTimeout(() => {
+            this.suppressContextSync = false;
+        }, 50);
+    }
+    /** True while the row has no user-entered content (ignores geographic defaults). */
+    shouldKeepExpandedForEntry(value) {
+        return (!value.street1?.trim() &&
+            !value.street2?.trim() &&
+            !value.postalCode?.trim() &&
+            !value.label?.id);
+    }
+    toObject(item) {
+        return this.addressService.normalizeAddressData(item);
+    }
+    setFormattedValue(item) {
+        if (this.format() === 'string') {
+            return item.full;
+        }
+        return item;
+    }
+    get __class() {
+        return 'block flex-1';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetEditComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXPAddressWidgetEditComponent, isStandalone: true, selector: "axp-address-widget-edit", host: { properties: { "class": "this.__class" } }, usesInheritance: true, ngImport: i0, template: `
+    @if (addressMode() === 'simple') {
+      <div class="grid grid-cols-12 gap-4 auto-cols-max">
+        <ax-text-box
+          [ngModel]="valueAsObject().full"
+          (onValueChanged)="handleValueChange($event)"
+          type="text"
+          name="full"
+          [placeholder]="placeholder()"
+          [ngClass]="generateClasses('value')"
+          [disabled]="disabled()"
+        >
+          @for (validation of validationRules(); track $index) {
+            <ax-validation-rule
+              [rule]="validation.rule"
+              [message]="validation.options?.message"
+              [options]="validation.options"
+            ></ax-validation-rule>
+          }
+        </ax-text-box>
+      </div>
+    } @else if (addressMode() === 'expandable') {
+      <div class="w-full">
+        <ax-accordion-group>
+          <ax-accordion-item
+            [headerTemplate]="collapseHeaderTemplate"
+            [isCollapsed]="collapsibleCollapsed()"
+            (isCollapsedChange)="onCollapsedChange($event)"
+          >
+            <div class="pt-1">
+              @for (formKey of [layoutRendererGeneration()]; track formKey) {
+                <axp-layout-renderer
+                  [layout]="addressFormLayout()"
+                  [context]="collapsibleFormContext()"
+                  (contextChange)="onCollapsibleFormContextChange($event)"
+                />
+              }
+            </div>
+          </ax-accordion-item>
+        </ax-accordion-group>
+      </div>
+
+      <ng-template #collapseHeaderTemplate>
+        <div class="ax-accordion-header-container">
+          <div class="ax-accordion-header-start">
+            <span
+              class="ax-accordion-header-icon fa-light fa-map-marker-alt"
+            ></span>
+            <span>
+              @if (collapsibleHeaderLabel()) {
+                <span class="font-semibold">{{
+                  collapsibleHeaderLabel()
+                }}</span>
+                @if (collapsibleHeaderAddress()) {
+                  <span> · {{ collapsibleHeaderAddress() }}</span>
+                }
+              } @else {
+                {{ collapsibleHeaderAddress() }}
+              }
+            </span>
+          </div>
+          <div class="ax-accordion-header-end">
+            <span
+              class="ax-icon ax-icon-chevron-left ax-accordion-arrow"
+              [class]="collapsibleCollapsed() ? '-rotation-90' : 'rotation-90'"
+            ></span>
+          </div>
+        </div>
+      </ng-template>
+    } @else {
+      <div class="grid grid-cols-12 gap-4 auto-cols-max">
+        <div class="flex items-center gap-2 col-span-12">
+          <ax-text-box
+            [ngModel]="formattedAddress()"
+            type="text"
+            [readonly]="true"
+            [placeholder]="placeholder()"
+            class="flex-1"
+            [disabled]="disabled()"
+          >
+            <ax-prefix>
+              <ax-icon icon="fa-light fa-map-marker-alt" />
+            </ax-prefix>
+            <ax-suffix>
+              <ax-button
+                look="flat"
+                size="sm"
+                [disabled]="disabled()"
+                (onClick)="showDetailsPopup()"
+              >
+                <ax-icon icon="fa-light fa-cog" />
+              </ax-button>
+            </ax-suffix>
+          </ax-text-box>
+        </div>
+      </div>
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: AXFormModule }, { kind: "directive", type: i3.AXValidationRuleDirective, selector: "ax-validation-rule", inputs: ["rule", "options", "message", "disabled"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i4.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "component", type: i5.AXTextBoxComponent, selector: "ax-text-box", inputs: ["disabled", "tabIndex", "readonly", "value", "state", "name", "id", "placeholder", "maxLength", "allowNull", "type", "autoComplete", "look", "maskPattern", "customTokens", "class"], outputs: ["onBlur", "onFocus", "valueChange", "stateChange", "onValueChanged", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress", "onMaskChanged"] }, { kind: "ngmodule", type: AXValidationModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i6.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: AXAccordionModule }, { kind: "component", type: i7.AXAccordionItemComponent, selector: "ax-accordion-item", inputs: ["isCollapsed", "icon", "textdecoration", "caption", "isLoading", "headerTemplate", "look", "disabled"], outputs: ["isCollapsedChange", "isLoadingChange", "onClick"] }, { kind: "component", type: i7.AXAccordionGroupComponent, selector: "ax-accordion-group", inputs: ["accordion", "activeIndex", "look", "collapsedOnItemClick"], outputs: ["activeIndexChange"] }, { kind: "component", type: AXPLayoutRendererComponent, selector: "axp-layout-renderer", inputs: ["layout", "context", "look", "mode"], outputs: ["contextChange", "contextInitiated", "validityChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-address-widget-edit',
+                    template: `
+    @if (addressMode() === 'simple') {
+      <div class="grid grid-cols-12 gap-4 auto-cols-max">
+        <ax-text-box
+          [ngModel]="valueAsObject().full"
+          (onValueChanged)="handleValueChange($event)"
+          type="text"
+          name="full"
+          [placeholder]="placeholder()"
+          [ngClass]="generateClasses('value')"
+          [disabled]="disabled()"
+        >
+          @for (validation of validationRules(); track $index) {
+            <ax-validation-rule
+              [rule]="validation.rule"
+              [message]="validation.options?.message"
+              [options]="validation.options"
+            ></ax-validation-rule>
+          }
+        </ax-text-box>
+      </div>
+    } @else if (addressMode() === 'expandable') {
+      <div class="w-full">
+        <ax-accordion-group>
+          <ax-accordion-item
+            [headerTemplate]="collapseHeaderTemplate"
+            [isCollapsed]="collapsibleCollapsed()"
+            (isCollapsedChange)="onCollapsedChange($event)"
+          >
+            <div class="pt-1">
+              @for (formKey of [layoutRendererGeneration()]; track formKey) {
+                <axp-layout-renderer
+                  [layout]="addressFormLayout()"
+                  [context]="collapsibleFormContext()"
+                  (contextChange)="onCollapsibleFormContextChange($event)"
+                />
+              }
+            </div>
+          </ax-accordion-item>
+        </ax-accordion-group>
+      </div>
+
+      <ng-template #collapseHeaderTemplate>
+        <div class="ax-accordion-header-container">
+          <div class="ax-accordion-header-start">
+            <span
+              class="ax-accordion-header-icon fa-light fa-map-marker-alt"
+            ></span>
+            <span>
+              @if (collapsibleHeaderLabel()) {
+                <span class="font-semibold">{{
+                  collapsibleHeaderLabel()
+                }}</span>
+                @if (collapsibleHeaderAddress()) {
+                  <span> · {{ collapsibleHeaderAddress() }}</span>
+                }
+              } @else {
+                {{ collapsibleHeaderAddress() }}
+              }
+            </span>
+          </div>
+          <div class="ax-accordion-header-end">
+            <span
+              class="ax-icon ax-icon-chevron-left ax-accordion-arrow"
+              [class]="collapsibleCollapsed() ? '-rotation-90' : 'rotation-90'"
+            ></span>
+          </div>
+        </div>
+      </ng-template>
+    } @else {
+      <div class="grid grid-cols-12 gap-4 auto-cols-max">
+        <div class="flex items-center gap-2 col-span-12">
+          <ax-text-box
+            [ngModel]="formattedAddress()"
+            type="text"
+            [readonly]="true"
+            [placeholder]="placeholder()"
+            class="flex-1"
+            [disabled]="disabled()"
+          >
+            <ax-prefix>
+              <ax-icon icon="fa-light fa-map-marker-alt" />
+            </ax-prefix>
+            <ax-suffix>
+              <ax-button
+                look="flat"
+                size="sm"
+                [disabled]="disabled()"
+                (onClick)="showDetailsPopup()"
+              >
+                <ax-icon icon="fa-light fa-cog" />
+              </ax-button>
+            </ax-suffix>
+          </ax-text-box>
+        </div>
+      </div>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        AXFormModule,
+                        AXDecoratorModule,
+                        AXTextBoxModule,
+                        AXValidationModule,
+                        AXTranslationModule,
+                        AXButtonModule,
+                        AXAccordionModule,
+                        AXPLayoutRendererComponent,
+                    ],
+                }]
+        }], propDecorators: { __class: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+
+var addressWidgetEdit_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPAddressWidgetEditComponent: AXPAddressWidgetEditComponent
+});
+
+class AXPAddressWidgetViewComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.addressService = inject(AXPAddressWidgetService);
+        this.hasLabel = computed(() => this.options()['hasLabel'] ?? false, ...(ngDevMode ? [{ debugName: "hasLabel" }] : /* istanbul ignore next */ []));
+        this.internalValue = computed(() => this.addressService.normalizeAddressData(this.getValue()), ...(ngDevMode ? [{ debugName: "internalValue" }] : /* istanbul ignore next */ []));
+        this.labelText = computed(() => this.internalValue().label?.title?.trim() ?? '', ...(ngDevMode ? [{ debugName: "labelText" }] : /* istanbul ignore next */ []));
+        this.formattedAddress = computed(() => {
+            const value = this.internalValue();
+            return value.full || this.addressService.formatAddress(value);
+        }, ...(ngDevMode ? [{ debugName: "formattedAddress" }] : /* istanbul ignore next */ []));
+        this.hasValue = computed(() => {
+            const rawValue = this.getValue();
+            if (isNull(rawValue))
+                return false;
+            const value = this.addressService.normalizeAddressData(rawValue);
+            return !isEmpty(value.full);
+        }, ...(ngDevMode ? [{ debugName: "hasValue" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXPAddressWidgetViewComponent, isStandalone: true, selector: "axp-address-widget-view", usesInheritance: true, ngImport: i0, template: `
+    @if (hasValue()) {
+      <div class="flex gap-2 items-center">
+        <div class="flex gap-2 group items-center justify-center truncate">
+          <span class="truncate">{{ formattedAddress() }}</span>
+        </div>
+        @if (hasLabel() && labelText()) {
+          <div><ax-badge color="primary" [look]="'twotone'" [text]="labelText()"></ax-badge></div>
+        }
+      </div>
+    } @else {
+      <span class="text-muted">---</span>
+    }
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: AXBadgeModule }, { kind: "component", type: i1$1.AXBadgeComponent, selector: "ax-badge", inputs: ["color", "look", "text"] }, { kind: "ngmodule", type: AXDecoratorModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-address-widget-view',
+                    template: `
+    @if (hasValue()) {
+      <div class="flex gap-2 items-center">
+        <div class="flex gap-2 group items-center justify-center truncate">
+          <span class="truncate">{{ formattedAddress() }}</span>
+        </div>
+        @if (hasLabel() && labelText()) {
+          <div><ax-badge color="primary" [look]="'twotone'" [text]="labelText()"></ax-badge></div>
+        }
+      </div>
+    } @else {
+      <span class="text-muted">---</span>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [FormsModule, AXBadgeModule, AXDecoratorModule],
+                }]
+        }] });
+
+var addressWidgetView_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPAddressWidgetViewComponent: AXPAddressWidgetViewComponent
+});
+
+class AXPAddressWidgetColumnComponent extends AXPColumnWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.clipboard = inject(AXPClipBoardService);
+        this.addressService = inject(AXPAddressWidgetService);
+        this.normalizedValue = computed(() => {
+            const raw = this.rawValue;
+            if (!raw)
+                return null;
+            return this.addressService.normalizeAddressData(raw);
+        }, ...(ngDevMode ? [{ debugName: "normalizedValue" }] : /* istanbul ignore next */ []));
+        this.formattedAddress = computed(() => {
+            const value = this.normalizedValue();
+            if (!value)
+                return '';
+            return value.full || this.addressService.formatAddress(value);
+        }, ...(ngDevMode ? [{ debugName: "formattedAddress" }] : /* istanbul ignore next */ []));
+        this.hasValue = computed(() => {
+            const value = this.normalizedValue();
+            if (!value)
+                return false;
+            return !isEmpty(value.full);
+        }, ...(ngDevMode ? [{ debugName: "hasValue" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetColumnComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXPAddressWidgetColumnComponent, isStandalone: true, selector: "axp-address-widget-column", inputs: { rawValue: "rawValue", rowData: "rowData" }, usesInheritance: true, ngImport: i0, template: `
+    @if (hasValue()) {
+      <div class="flex justify-start items-center gap-2 group w-fit">
+        <span class="truncate" [title]="formattedAddress()">{{ formattedAddress() }}</span>
+        <i
+          (click)="clipboard.copy('Address', formattedAddress())"
+          class="fa-solid fa-copy text-neutral-400 dark:hover:text-neutral-100 hover:text-neutral-900 group-hover:visible invisible"
+        ></i>
+      </div>
+    } @else {
+      <span class="text-muted">---</span>
+    }
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXPAddressWidgetColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-address-widget-column',
+                    template: `
+    @if (hasValue()) {
+      <div class="flex justify-start items-center gap-2 group w-fit">
+        <span class="truncate" [title]="formattedAddress()">{{ formattedAddress() }}</span>
+        <i
+          (click)="clipboard.copy('Address', formattedAddress())"
+          class="fa-solid fa-copy text-neutral-400 dark:hover:text-neutral-100 hover:text-neutral-900 group-hover:visible invisible"
+        ></i>
+      </div>
+    } @else {
+      <span class="text-muted">---</span>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    inputs: ['rawValue', 'rowData'],
+                }]
+        }] });
+
+var addressWidgetColumn_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPAddressWidgetColumnComponent: AXPAddressWidgetColumnComponent
+});
+
+//#endregion
+//#region ----   Location Management Widgets Provider   ----
+const LOCATION_WIDGETS = [AXPAddressWidget];
+/**
+ * Provider for location-management widgets (Address editor).
+ * The address widget lives here because its service depends on `@acorex-platform/framework-client/layout/entity`,
+ * which would otherwise create a circular dependency with `@acorex-platform/framework-client/layout/widgets`.
+ */
+class AXMLocationManagementWidgetsProvider {
+    getWidgets() {
+        return LOCATION_WIDGETS;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementWidgetsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementWidgetsProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementWidgetsProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMLocationManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementModule, imports: [CommonModule,
+            AXPWidgetCoreModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementModule, providers: [
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: LocationManagementManifest,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMLocationManagementPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMLocationManagementMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMLocationManagementEntityProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                multi: true,
+                useValue: locationAssignmentLocationHydrateMiddleware,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMSettingProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXMSearchCommandProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_FEATURE_DEFINITION_PROVIDER,
+                useClass: AXMLocationManagementFeatureDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                useClass: AXMGeographicRegionDataSourceDefinition,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMLocationManagementWidgetsProvider,
+                multi: true,
+            },
+            provideCommandSetups([
+                {
+                    key: `${RootConfig.module.name}.${RootConfig.entities.locationAssignment.name}:AssignExistingLocation`,
+                    command: () => import('./acorex-platform-module-location-management-client-assign-existing-location-to-party.command-DmpN-yas.mjs').then((c) => c.AXMLocationAssignmentAssignExistingLocationCommand),
+                },
+                {
+                    key: `${RootConfig.module.name}.${RootConfig.entities.locationAssignment.name}:CreateWithNewLocation`,
+                    command: () => import('./acorex-platform-module-location-management-client-create-location-with-assignment.command-D6VXtZRf.mjs').then((c) => c.AXMLocationAssignmentCreateWithNewLocationCommand),
+                },
+            ]),
+        ], imports: [CommonModule,
+            AXPWidgetCoreModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        AXPWidgetCoreModule,
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: LocationManagementManifest,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMLocationManagementPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMLocationManagementMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMLocationManagementEntityProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_ENTITY_STORAGE_MIDDLEWARE,
+                            multi: true,
+                            useValue: locationAssignmentLocationHydrateMiddleware,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMSettingProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXMSearchCommandProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_FEATURE_DEFINITION_PROVIDER,
+                            useClass: AXMLocationManagementFeatureDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATASOURCE_DEFINITION_PROVIDER,
+                            useClass: AXMGeographicRegionDataSourceDefinition,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMLocationManagementWidgetsProvider,
+                            multi: true,
+                        },
+                        provideCommandSetups([
+                            {
+                                key: `${RootConfig.module.name}.${RootConfig.entities.locationAssignment.name}:AssignExistingLocation`,
+                                command: () => import('./acorex-platform-module-location-management-client-assign-existing-location-to-party.command-DmpN-yas.mjs').then((c) => c.AXMLocationAssignmentAssignExistingLocationCommand),
+                            },
+                            {
+                                key: `${RootConfig.module.name}.${RootConfig.entities.locationAssignment.name}:CreateWithNewLocation`,
+                                command: () => import('./acorex-platform-module-location-management-client-create-location-with-assignment.command-D6VXtZRf.mjs').then((c) => c.AXMLocationAssignmentCreateWithNewLocationCommand),
+                            },
+                        ]),
+                    ]
+                }]
+        }] });
+
+class AXMLocationManagementService {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.geographicRegionDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.geographicRegion.name)
+            .data();
+    }
+    async getCountries() {
+        const result = await this.geographicRegionDataAccessor.query({
+            skip: 0,
+            take: 1000,
+            filter: { field: 'type', operator: { type: 'equal' }, value: 'country' },
+            sort: [{ field: 'title', dir: 'asc' }],
+        });
+        return result.items.map((m) => ({
+            code: m.code,
+            title: m.title,
+            id: m.id,
+            timezone: m.timezone,
+        }));
+    }
+    async getProvinces(countryId) {
+        const result = await this.geographicRegionDataAccessor.query({
+            skip: 0,
+            take: 1000,
+            filter: { field: 'type', operator: { type: 'equal' }, value: 'state' },
+            sort: [{ field: 'title', dir: 'asc' }],
+        });
+        return result.items.map((m) => ({
+            code: m.code,
+            title: m.title,
+            id: m.id,
+            timezone: m.timezone,
+        }));
+    }
+    async getCities(filter) {
+        const result = await this.geographicRegionDataAccessor.query({
+            skip: 0,
+            take: 1000,
+            filter: { field: 'type', operator: { type: 'equal' }, value: 'city' },
+            sort: [{ field: 'title', dir: 'asc' }],
+        });
+        return result.items.map((m) => ({
+            code: m.code,
+            title: m.title,
+            id: m.id,
+            timezone: m.timezone,
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMLocationManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMLocationManagementEntityProvider, AXMLocationManagementMenuProvider, AXMLocationManagementModule, AXMLocationManagementService, AXMSearchCommandProvider, AXMSettingProvider };
+//# sourceMappingURL=acorex-platform-module-location-management-client.mjs.map