@acorex-platform/module-risk-management-client 0.0.21

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

@@ -0,0 +1,1089 @@
+import { AXPCommonMenuKeys, AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import * as i0 from '@angular/core';
+import { inject, Injectable, NgModule, input, output, signal, computed, effect, ChangeDetectionStrategy, ViewEncapsulation, Component } from '@angular/core';
+import { RootConfig, AXPSafetyRiskPermissionKeys, AXMRiskManagementMenuKeys, RISK_CATALOG_SCOPE_HAZARD, RISK_CATALOG_SCOPE_PPE_ITEMS, RISK_MATRIX_AXIS_PROPERTIES, DEFAULT_RISK_MATRIX_AXIS_MAPPING, DEFAULT_RISK_MATRIX_ORIENTATION, RISK_MATRIX_ORIENTATION_TITLE_KEYS } from '@acorex-platform/module-risk-management-client/contracts';
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXP_MENU_PROVIDER, resolveEntityRowDisplayText, resolveEntityRowDisplayTitle } from '@acorex-platform/framework-client/common';
+import { AXP_MODULE_MANIFEST_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, provideLazyProvider } from '@acorex-platform/framework-client/core';
+import { AXP_WIDGETS_EDITOR_CATEGORY, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER, AXPColumnWidgetComponent, AXPValueWidgetComponent } from '@acorex-platform/framework-client/layout/widget-core';
+import { provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import { AXPWidgetGroupEnum } from '@acorex-platform/framework-shared/widget-core';
+import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXP_LABEL_PROPERTY, AXP_READONLY_PROPERTY, AXP_DISABLED_PROPERTY } from '@acorex-platform/framework-client/layout/widgets';
+import * as i2 from '@acorex/core/translation';
+import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
+import { extractValue, AXPWidgetsList } from '@acorex-platform/framework-shared/core';
+import { AXPSpreadsheetComponent } from '@acorex-platform/framework-client/layout/components';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { isEmpty, defaultTo, get, isEqual, castArray } from 'lodash';
+import { AXPLayoutBuilderService } from '@acorex-platform/framework-client/layout/builder';
+import * as i1$1 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2$1 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import { AXFormatService } from '@acorex/core/format';
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Menu provider ----
+class AXMRiskManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const entities = RootConfig.entities;
+        const keys = AXPSafetyRiskPermissionKeys;
+        context.find(AXPCommonMenuKeys.Configuration).addItems([
+            {
+                name: AXMRiskManagementMenuKeys.Root,
+                priority: 8950,
+                text: `@${RootConfig.config.i18n}:module.menus.risk`,
+                icon: module.icon,
+                type: 'menu',
+                policy: {
+                    features: [module.name],
+                },
+                children: [
+                    {
+                        name: AXMRiskManagementMenuKeys.RiskMatrixCells,
+                        text: entities.riskMatrixCell.titlePlural,
+                        icon: entities.riskMatrixCell.icon,
+                        priority: 1,
+                        path: this.entityService.createPath(module.name, entities.riskMatrixCell.name),
+                        policy: {
+                            permissions: [keys.MaintainRisk],
+                        },
+                    },
+                    {
+                        name: AXMRiskManagementMenuKeys.RiskLikelihoods,
+                        text: entities.riskLikelihood.titlePlural,
+                        icon: entities.riskLikelihood.icon,
+                        priority: 2,
+                        path: this.entityService.createPath(module.name, entities.riskLikelihood.name),
+                        policy: {
+                            permissions: [keys.Setup],
+                        },
+                    },
+                    {
+                        name: AXMRiskManagementMenuKeys.RiskSeverities,
+                        text: entities.riskSeverity.titlePlural,
+                        icon: entities.riskSeverity.icon,
+                        priority: 3,
+                        path: this.entityService.createPath(module.name, entities.riskSeverity.name),
+                        policy: {
+                            permissions: [keys.Setup],
+                        },
+                    },
+                    {
+                        name: AXMRiskManagementMenuKeys.RiskRatings,
+                        text: entities.riskRating.titlePlural,
+                        icon: entities.riskRating.icon,
+                        priority: 4,
+                        path: this.entityService.createPath(module.name, entities.riskRating.name),
+                        policy: {
+                            permissions: [keys.Setup],
+                        },
+                    },
+                ],
+            },
+        ]);
+    }
+}
+//#endregion
+
+var menu_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMRiskManagementMenuProvider: AXMRiskManagementMenuProvider
+});
+
+//#endregion
+//#region ---- Permission Definition Provider ----
+/**
+ * Registers risk capabilities into the shared Safety & Risk group.
+ */
+class AXMRiskManagementPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPSafetyRiskPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:safety-risk.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.SafetyRisk.Root, `${G}.safety-risk.title`, `${G}.safety-risk.description`, { order: 30 });
+        context
+            .addGroup(groups.SafetyRisk.Risk, `${G}.safety-risk-risk.title`, `${G}.safety-risk-risk.description`, { parent: groups.SafetyRisk.Root, order: 20 })
+            .addPermission(keys.MaintainRisk, `${P}.maintain-risk.title`, `${P}.maintain-risk.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+var permissionDefinition_provider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMRiskManagementPermissionDefinitionProvider: AXMRiskManagementPermissionDefinitionProvider
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Risk Management module manifest.
+ */
+const RiskManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'domain',
+    domain: 'workplace-safety',
+    required: false,
+};
+//#endregion
+
+//#endregion
+//#region ---- Constants ----
+const RISK_MATRIX_CELL = `${RootConfig.module.name}.${RootConfig.entities.riskMatrixCell.name}`;
+const RISK_MATRIX_CELL_CATALOG_TARGETS = [RISK_MATRIX_CELL];
+//#endregion
+//#region ---- Provider ----
+class AXMRiskManagementCatalogScopeDefinitionProvider {
+    async items() {
+        return [
+            {
+                name: RISK_CATALOG_SCOPE_HAZARD,
+                title: '@risk-management:catalog-scopes.hazard.title',
+                description: '@risk-management:catalog-scopes.hazard.description',
+                targets: [...RISK_MATRIX_CELL_CATALOG_TARGETS],
+                icon: 'fa-light fa-triangle-exclamation',
+                cssClass: 'warning-lighter-surface',
+                order: 20,
+            },
+            {
+                name: RISK_CATALOG_SCOPE_PPE_ITEMS,
+                title: '@risk-management:catalog-scopes.ppe-items.title',
+                description: '@risk-management:catalog-scopes.ppe-items.description',
+                targets: [...RISK_MATRIX_CELL_CATALOG_TARGETS],
+                icon: 'fa-light fa-helmet-safety',
+                cssClass: 'info-lighter-surface',
+                order: 21,
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementCatalogScopeDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementCatalogScopeDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementCatalogScopeDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Widget Config   ----
+const AXMRiskMatrixWidget = {
+    name: 'risk-matrix-editor',
+    title: 'Risk Matrix',
+    categories: AXP_WIDGETS_EDITOR_CATEGORY,
+    groups: [AXPWidgetGroupEnum.UtilityWidget],
+    description: 'Matrix widget for mapping likelihood and severity combinations to risk ratings',
+    icon: 'fa-light fa-table-cells',
+    type: 'editor',
+    options: {
+        needLabel: false,
+    },
+    properties: [
+        AXP_NAME_PROPERTY,
+        AXP_DATA_PATH_PROPERTY,
+        AXP_LABEL_PROPERTY,
+        AXP_READONLY_PROPERTY,
+        AXP_DISABLED_PROPERTY,
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return riskMatrixWidgetView_component; }).then((c) => c.AXMRiskMatrixWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return riskMatrixWidgetEdit_component; }).then((c) => c.AXMRiskMatrixWidgetEditComponent),
+        },
+        column: {
+            component: () => Promise.resolve().then(function () { return riskMatrixWidgetColumn_component; }).then((c) => c.AXMRiskMatrixWidgetColumnComponent),
+        },
+    },
+};
+//#endregion
+
+//#endregion
+//#region ----   Risk Management Widgets Provider   ----
+class AXMRiskManagementWidgetsProvider {
+    getWidgets() {
+        return [AXMRiskMatrixWidget];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementWidgetsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementWidgetsProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementWidgetsProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+class AXMRiskManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementModule, imports: [AXPWidgetCoreModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementModule, providers: [
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: RiskManagementManifest,
+                multi: true,
+            },
+            provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMRiskManagementPermissionDefinitionProvider)),
+            provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMRiskManagementMenuProvider)),
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMRiskManagementWidgetsProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                useClass: AXMRiskManagementCatalogScopeDefinitionProvider,
+                multi: true,
+            },
+            provideCommandSetups([
+                {
+                    key: `${RootConfig.module.name}.${RootConfig.entities.riskMatrixCell.name}:Preview`,
+                    command: () => import('./acorex-platform-module-risk-management-client-preview-risk-matrix-cell.command-CTGIFUIa.mjs').then((c) => c.AXMPreviewRiskMatrixCellCommand),
+                },
+            ]),
+        ], imports: [AXPWidgetCoreModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWidgetCoreModule,
+                    ],
+                    providers: [
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: RiskManagementManifest,
+                            multi: true,
+                        },
+                        provideLazyProvider(AXP_PERMISSION_DEFINITION_PROVIDER, () => Promise.resolve().then(function () { return permissionDefinition_provider; }).then((m) => m.AXMRiskManagementPermissionDefinitionProvider)),
+                        provideLazyProvider(AXP_MENU_PROVIDER, () => Promise.resolve().then(function () { return menu_provider; }).then((m) => m.AXMRiskManagementMenuProvider)),
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMRiskManagementWidgetsProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                            useClass: AXMRiskManagementCatalogScopeDefinitionProvider,
+                            multi: true,
+                        },
+                        provideCommandSetups([
+                            {
+                                key: `${RootConfig.module.name}.${RootConfig.entities.riskMatrixCell.name}:Preview`,
+                                command: () => import('./acorex-platform-module-risk-management-client-preview-risk-matrix-cell.command-CTGIFUIa.mjs').then((c) => c.AXMPreviewRiskMatrixCellCommand),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Helpers   ----
+function isRiskMatrixAxisProperty(value) {
+    return typeof value === 'string' && RISK_MATRIX_AXIS_PROPERTIES.includes(value);
+}
+function resolveRiskMatrixAxisMapping(mapping) {
+    const rowProperty = isRiskMatrixAxisProperty(mapping?.rowProperty)
+        ? mapping.rowProperty
+        : DEFAULT_RISK_MATRIX_AXIS_MAPPING.rowProperty;
+    const columnProperty = isRiskMatrixAxisProperty(mapping?.columnProperty)
+        ? mapping.columnProperty
+        : DEFAULT_RISK_MATRIX_AXIS_MAPPING.columnProperty;
+    const depthProperty = isRiskMatrixAxisProperty(mapping?.depthProperty)
+        ? mapping.depthProperty
+        : DEFAULT_RISK_MATRIX_AXIS_MAPPING.depthProperty;
+    if (validateRiskMatrixAxisMapping({ rowProperty, columnProperty, depthProperty })) {
+        return { rowProperty, columnProperty, depthProperty };
+    }
+    return { ...DEFAULT_RISK_MATRIX_AXIS_MAPPING };
+}
+function isRiskMatrixOrientation(value) {
+    return value === 'likelihood-rows' || value === 'severity-rows';
+}
+/**
+ * Normalizes orientation from persisted strings or SelectionList row objects (`{ id }`).
+ */
+function resolveRiskMatrixOrientation(value) {
+    const candidate = extractValue(value, 'id') ?? value;
+    return isRiskMatrixOrientation(candidate) ? candidate : DEFAULT_RISK_MATRIX_ORIENTATION;
+}
+/** Translation key for the spreadsheet corner title (`row axis / column axis`). */
+function resolveRiskMatrixTitleKey(orientation) {
+    return RISK_MATRIX_ORIENTATION_TITLE_KEYS[resolveRiskMatrixOrientation(orientation)];
+}
+function pickDefinedAxisMapping(mapping) {
+    if (!mapping) {
+        return {};
+    }
+    const picked = {};
+    if (isRiskMatrixAxisProperty(mapping.rowProperty)) {
+        picked.rowProperty = mapping.rowProperty;
+    }
+    if (isRiskMatrixAxisProperty(mapping.columnProperty)) {
+        picked.columnProperty = mapping.columnProperty;
+    }
+    if (isRiskMatrixAxisProperty(mapping.depthProperty)) {
+        picked.depthProperty = mapping.depthProperty;
+    }
+    return picked;
+}
+function resolveRiskMatrixAxisMappingFromOrientation(orientation, mapping) {
+    const resolvedOrientation = resolveRiskMatrixOrientation(orientation);
+    const orientationMapping = resolvedOrientation === 'severity-rows'
+        ? { rowProperty: 'severityId', columnProperty: 'likelihoodId', depthProperty: 'riskRatingId' }
+        : { rowProperty: 'likelihoodId', columnProperty: 'severityId', depthProperty: 'riskRatingId' };
+    return resolveRiskMatrixAxisMapping({
+        ...pickDefinedAxisMapping(mapping),
+        ...orientationMapping,
+    });
+}
+/**
+ * Persisted matrix shape is always likelihood × severity → risk rating.
+ * Transpose only for display when severity is shown as rows.
+ */
+function toDisplayMatrixData(canonical, orientation) {
+    if (resolveRiskMatrixOrientation(orientation) === 'likelihood-rows') {
+        return canonical;
+    }
+    const display = {};
+    Object.entries(canonical).forEach(([likelihoodId, severityMap]) => {
+        if (!severityMap) {
+            return;
+        }
+        Object.entries(severityMap).forEach(([severityId, ratingId]) => {
+            display[severityId] ??= {};
+            display[severityId][likelihoodId] = ratingId;
+        });
+    });
+    return display;
+}
+/** Converts display-oriented matrix data back to canonical likelihood × severity storage. */
+function toCanonicalMatrixData(display, orientation) {
+    if (resolveRiskMatrixOrientation(orientation) === 'likelihood-rows') {
+        return display;
+    }
+    const canonical = {};
+    Object.entries(display).forEach(([severityId, likelihoodMap]) => {
+        if (!likelihoodMap) {
+            return;
+        }
+        Object.entries(likelihoodMap).forEach(([likelihoodId, ratingId]) => {
+            canonical[likelihoodId] ??= {};
+            canonical[likelihoodId][severityId] = ratingId;
+        });
+    });
+    return canonical;
+}
+/** Normalizes lookup axis values (ids or `{ id }` rows) to string ids. */
+function normalizeRiskMatrixAxisIds(value) {
+    const items = Array.isArray(value) ? value : value != null ? [value] : [];
+    return items
+        .map((item) => {
+        if (item != null && typeof item === 'object' && 'id' in item) {
+            return String(item.id);
+        }
+        return item != null ? String(item) : '';
+    })
+        .filter((id) => id.length > 0);
+}
+/**
+ * Drops matrix entries for axes no longer selected on the record.
+ * Persisted shape stays likelihood × severity → risk rating.
+ */
+function pruneMatrixToAxes(matrix, likelihoodIds, severityIds) {
+    const likelihoodSet = new Set(likelihoodIds);
+    const severitySet = new Set(severityIds);
+    const pruned = {};
+    Object.entries(matrix ?? {}).forEach(([likelihoodId, severityMap]) => {
+        if (!likelihoodSet.has(likelihoodId) || severityMap == null) {
+            return;
+        }
+        const row = {};
+        Object.entries(severityMap).forEach(([severityId, ratingId]) => {
+            if (severitySet.has(severityId)) {
+                row[severityId] = ratingId;
+            }
+        });
+        if (Object.keys(row).length > 0) {
+            pruned[likelihoodId] = row;
+        }
+    });
+    return pruned;
+}
+function validateRiskMatrixAxisMapping(mapping) {
+    const rowProperty = mapping.rowProperty;
+    const columnProperty = mapping.columnProperty;
+    const depthProperty = mapping.depthProperty;
+    if (!isRiskMatrixAxisProperty(rowProperty)) {
+        return false;
+    }
+    if (!isRiskMatrixAxisProperty(columnProperty)) {
+        return false;
+    }
+    if (!isRiskMatrixAxisProperty(depthProperty)) {
+        return false;
+    }
+    const values = [rowProperty, columnProperty, depthProperty];
+    return new Set(values).size === values.length;
+}
+//#endregion
+
+//#region ----   Constants   ----
+/** Default matrix badge colors when {@link color} is not set on a risk rating record. */
+const DEFAULT_RISK_RATING_BADGE_COLORS = {
+    low: 'warning-lighter-surface',
+    medium: 'success-lighter-surface',
+    high: 'danger-lighter-surface',
+};
+//#endregion
+//#region ----   Helpers   ----
+function resolveRiskRatingBadgeColor(rating) {
+    const color = rating.color?.trim();
+    if (color) {
+        return color;
+    }
+    const code = rating.code?.trim().toUpperCase();
+    if (code?.endsWith('0001')) {
+        return DEFAULT_RISK_RATING_BADGE_COLORS.low;
+    }
+    if (code?.endsWith('0002')) {
+        return DEFAULT_RISK_RATING_BADGE_COLORS.medium;
+    }
+    if (code?.endsWith('0003')) {
+        return DEFAULT_RISK_RATING_BADGE_COLORS.high;
+    }
+    const title = rating.title?.trim().toLowerCase();
+    if (title === 'low') {
+        return DEFAULT_RISK_RATING_BADGE_COLORS.low;
+    }
+    if (title === 'medium') {
+        return DEFAULT_RISK_RATING_BADGE_COLORS.medium;
+    }
+    if (title === 'high') {
+        return DEFAULT_RISK_RATING_BADGE_COLORS.high;
+    }
+    return undefined;
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Component Definition   ----
+class AXMRiskManagementRiskMatrixComponent {
+    //#endregion
+    //#region ----   Lifecycle Methods   ----
+    constructor() {
+        //#endregion
+        //#region ----   Services & Dependencies   ----
+        this.entityService = inject(AXPEntityService);
+        this.likelihoodDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.riskLikelihood.name)
+            .data();
+        this.severityDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.riskSeverity.name)
+            .data();
+        this.riskRatingDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.riskRating.name)
+            .data();
+        this.multiLanguageResolver = inject(AXTranslationService);
+        //#endregion
+        //#region ----   Inputs   ----
+        /** Axis mapping. Defaults to likelihood × severity → risk rating. */
+        this.axisMapping = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "axisMapping" }] : /* istanbul ignore next */ []));
+        /** Selected axis item ids from the parent matrix record. */
+        this.likelihoodIds = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "likelihoodIds" }] : /* istanbul ignore next */ []));
+        this.severityIds = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "severityIds" }] : /* istanbul ignore next */ []));
+        /** Controls row/column layout only; persisted matrix stays likelihood × severity. */
+        this.matrixOrientation = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixOrientation" }] : /* istanbul ignore next */ []));
+        /** Matrix data: { [likelihoodId]: { [severityId]: riskRatingId } } */
+        this.value = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+        this.readonly = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Outputs   ----
+        this.valueChange = output();
+        this.cellChange = output();
+        //#endregion
+        //#region ----   Class Properties   ----
+        this.likelihoodItems = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "likelihoodItems" }] : /* istanbul ignore next */ []));
+        this.severityItems = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "severityItems" }] : /* istanbul ignore next */ []));
+        this.depthItems = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "depthItems" }] : /* istanbul ignore next */ []));
+        this.hasLoadedAxesOnce = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasLoadedAxesOnce" }] : /* istanbul ignore next */ []));
+        this.isLoading = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isLoading" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Computed Properties   ----
+        this.resolvedMatrixOrientation = computed(() => resolveRiskMatrixOrientation(this.matrixOrientation()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "resolvedMatrixOrientation" }] : /* istanbul ignore next */ []));
+        this.resolvedAxisMapping = computed(() => resolveRiskMatrixAxisMappingFromOrientation(this.resolvedMatrixOrientation(), this.axisMapping()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "resolvedAxisMapping" }] : /* istanbul ignore next */ []));
+        this.displayMatrix = computed(() => toDisplayMatrixData(this.value(), this.resolvedMatrixOrientation()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "displayMatrix" }] : /* istanbul ignore next */ []));
+        this.matrixTitleKey = computed(() => resolveRiskMatrixTitleKey(this.resolvedMatrixOrientation()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixTitleKey" }] : /* istanbul ignore next */ []));
+        this.verticalTitles = computed(() => this.toSpreadsheetItems(this.resolvedRowItems()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "verticalTitles" }] : /* istanbul ignore next */ []));
+        this.horizontalTitles = computed(() => this.toSpreadsheetItems(this.resolvedColumnItems()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "horizontalTitles" }] : /* istanbul ignore next */ []));
+        this.cellOptions = computed(() => this.toSpreadsheetItems(this.depthItems()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "cellOptions" }] : /* istanbul ignore next */ []));
+        this.resolvedRowItems = computed(() => {
+            const mapping = this.resolvedAxisMapping();
+            return mapping.rowProperty === 'likelihoodId' ? this.likelihoodItems() : this.severityItems();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "resolvedRowItems" }] : /* istanbul ignore next */ []));
+        this.resolvedColumnItems = computed(() => {
+            const mapping = this.resolvedAxisMapping();
+            return mapping.columnProperty === 'likelihoodId' ? this.likelihoodItems() : this.severityItems();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "resolvedColumnItems" }] : /* istanbul ignore next */ []));
+        this.spreadsheetColumns = computed(() => {
+            const horizontalTitles = this.horizontalTitles();
+            const ratingItems = this.depthItems();
+            const cellOptions = this.toSpreadsheetItems(ratingItems);
+            const selectBoxWidget = {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'id',
+                    textField: 'title',
+                    cssClassField: 'color',
+                    dataSource: cellOptions.map((option, index) => ({
+                        id: option.id,
+                        title: option.title,
+                        description: option.description,
+                        color: ratingItems[index]?.color,
+                    })),
+                },
+            };
+            return horizontalTitles.map((title) => ({
+                name: title.id,
+                title: title.title,
+                description: title.description,
+                path: title.id,
+                widget: selectBoxWidget,
+            }));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "spreadsheetColumns" }] : /* istanbul ignore next */ []));
+        this.spreadsheetRows = computed(() => {
+            const verticalTitles = this.verticalTitles();
+            const horizontalTitles = this.horizontalTitles();
+            const matrixData = this.displayMatrix();
+            return verticalTitles.map((row) => {
+                const rowData = {
+                    name: row.id,
+                    _rowTitle: row.title,
+                    _rowDescription: row.description,
+                };
+                horizontalTitles.forEach((column) => {
+                    rowData[column.id] = matrixData[row.id]?.[column.id] ?? null;
+                });
+                return rowData;
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "spreadsheetRows" }] : /* istanbul ignore next */ []));
+        effect(() => {
+            const likelihoodIds = this.likelihoodIds();
+            const severityIds = this.severityIds();
+            void this.loadMatrixAxes(likelihoodIds, severityIds);
+        });
+    }
+    //#endregion
+    //#region ----   Data Loading Methods   ----
+    async loadMatrixAxes(likelihoodIds, severityIds) {
+        const isInitialLoad = !this.hasLoadedAxesOnce();
+        try {
+            if (isInitialLoad) {
+                this.isLoading.set(true);
+            }
+            const query = {
+                skip: 0,
+                take: 1000,
+                sort: [{ field: 'levelValue', dir: 'asc' }],
+            };
+            const [likelihoodResult, severityResult, depthResult] = await Promise.all([
+                this.queryAxisItems('likelihoodId', query, likelihoodIds),
+                this.queryAxisItems('severityId', query, severityIds),
+                this.queryAxisItems('riskRatingId', query),
+            ]);
+            this.likelihoodItems.set(likelihoodResult);
+            this.severityItems.set(severityResult);
+            this.depthItems.set(depthResult);
+            this.hasLoadedAxesOnce.set(true);
+        }
+        catch (error) {
+            console.error('Error loading risk matrix axes:', error);
+            this.likelihoodItems.set([]);
+            this.severityItems.set([]);
+            this.depthItems.set([]);
+        }
+        finally {
+            if (isInitialLoad) {
+                this.isLoading.set(false);
+            }
+        }
+    }
+    async queryAxisItems(property, query, selectedIds) {
+        const accessor = this.getAxisDataAccessor(property);
+        const result = await accessor.query(query);
+        const items = (result.items ?? []).map((item) => {
+            const base = {
+                id: item.id,
+                title: item.title,
+                description: item.description,
+            };
+            if (property !== 'riskRatingId') {
+                return base;
+            }
+            const rating = item;
+            const color = resolveRiskRatingBadgeColor(rating);
+            return color ? { ...base, color } : base;
+        });
+        if (isEmpty(selectedIds)) {
+            return items;
+        }
+        const selectedIdSet = new Set(selectedIds);
+        return items.filter((item) => selectedIdSet.has(item.id));
+    }
+    getAxisDataAccessor(property) {
+        switch (property) {
+            case 'severityId':
+                return this.severityDataAccessor;
+            case 'riskRatingId':
+                return this.riskRatingDataAccessor;
+            case 'likelihoodId':
+            default:
+                return this.likelihoodDataAccessor;
+        }
+    }
+    //#endregion
+    //#region ----   Data Transformation Methods   ----
+    toSpreadsheetItems(items) {
+        const resolve = (v) => this.multiLanguageResolver.resolve(v);
+        return items.map((item) => ({
+            id: item.id,
+            title: resolve(item.title),
+            description: item.description ? resolve(item.description) : undefined,
+        }));
+    }
+    convertSpreadsheetRowsToMatrixData(rows) {
+        const horizontalTitles = this.horizontalTitles();
+        const matrixData = {};
+        rows.forEach((row) => {
+            const rowId = row['name'];
+            if (!rowId) {
+                return;
+            }
+            matrixData[rowId] = {};
+            horizontalTitles.forEach((column) => {
+                matrixData[rowId][column.id] = row[column.id] ?? null;
+            });
+        });
+        return matrixData;
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    handleSpreadsheetChange(rows) {
+        const displayMatrix = this.convertSpreadsheetRowsToMatrixData(rows);
+        this.valueChange.emit(toCanonicalMatrixData(displayMatrix, this.resolvedMatrixOrientation()));
+    }
+    handleCellChange(event) {
+        this.cellChange.emit(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementRiskMatrixComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMRiskManagementRiskMatrixComponent, isStandalone: true, selector: "axm-risk-matrix", inputs: { axisMapping: { classPropertyName: "axisMapping", publicName: "axisMapping", isSignal: true, isRequired: false, transformFunction: null }, likelihoodIds: { classPropertyName: "likelihoodIds", publicName: "likelihoodIds", isSignal: true, isRequired: false, transformFunction: null }, severityIds: { classPropertyName: "severityIds", publicName: "severityIds", isSignal: true, isRequired: false, transformFunction: null }, matrixOrientation: { classPropertyName: "matrixOrientation", publicName: "matrixOrientation", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, readonly: { classPropertyName: "readonly", publicName: "readonly", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { valueChange: "valueChange", cellChange: "cellChange" }, host: { classAttribute: "axm-risk-matrix" }, ngImport: i0, template: "<div class=\"__container\">\n  <div class=\"__matrix-section\">\n    @if (isLoading()) {\n      <div class=\"__loading\">\n        <span>{{ '@risk-management:risk-matrix-cells.components.risk-matrix.messages.loading' | translate | async }}</span>\n      </div>\n    } @else {\n      @for (_ of [resolvedMatrixOrientation()]; track _) {\n        <axp-spreadsheet\n          [title]=\"(matrixTitleKey() | translate | async) ?? ''\"\n          [columns]=\"spreadsheetColumns()\"\n          [rowsInput]=\"spreadsheetRows()\"\n          [rowMode]=\"'fixed'\"\n          [readonly]=\"readonly()\"\n          [allowRemoveRows]=\"false\"\n          [rowTitlePath]=\"'_rowTitle'\"\n          [rowDescriptionPath]=\"'_rowDescription'\"\n          (cellChange)=\"handleCellChange($event)\"\n          (spreadsheetChange)=\"handleSpreadsheetChange($event)\"\n        ></axp-spreadsheet>\n      }\n    }\n  </div>\n</div>\n", styles: [".risk-matrix{display:block;height:100%;width:100%}.risk-matrix .__container,.risk-matrix .__matrix-section{display:flex;flex-direction:column}.risk-matrix .__loading,.risk-matrix .__empty-state{display:flex;align-items:center;justify-content:center;padding:calc(var(--spacing, .25rem) * 8);font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:rgb(var(--ax-sys-color-on-light-surface))}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: AXPSpreadsheetComponent, selector: "axp-spreadsheet", inputs: ["title", "columns", "rowMode", "rowsInput", "rowsModel", "readonly", "emptyCellPlaceholder", "rowTitlePath", "rowDescriptionPath", "allowAddRows", "allowRemoveRows"], outputs: ["rowsModelChange", "cellChange", "rowChange", "spreadsheetChange"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i2.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskManagementRiskMatrixComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-risk-matrix', standalone: true, imports: [CommonModule, AXPSpreadsheetComponent, AXTranslationModule], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'axm-risk-matrix',
+                    }, template: "<div class=\"__container\">\n  <div class=\"__matrix-section\">\n    @if (isLoading()) {\n      <div class=\"__loading\">\n        <span>{{ '@risk-management:risk-matrix-cells.components.risk-matrix.messages.loading' | translate | async }}</span>\n      </div>\n    } @else {\n      @for (_ of [resolvedMatrixOrientation()]; track _) {\n        <axp-spreadsheet\n          [title]=\"(matrixTitleKey() | translate | async) ?? ''\"\n          [columns]=\"spreadsheetColumns()\"\n          [rowsInput]=\"spreadsheetRows()\"\n          [rowMode]=\"'fixed'\"\n          [readonly]=\"readonly()\"\n          [allowRemoveRows]=\"false\"\n          [rowTitlePath]=\"'_rowTitle'\"\n          [rowDescriptionPath]=\"'_rowDescription'\"\n          (cellChange)=\"handleCellChange($event)\"\n          (spreadsheetChange)=\"handleSpreadsheetChange($event)\"\n        ></axp-spreadsheet>\n      }\n    }\n  </div>\n</div>\n", styles: [".risk-matrix{display:block;height:100%;width:100%}.risk-matrix .__container,.risk-matrix .__matrix-section{display:flex;flex-direction:column}.risk-matrix .__loading,.risk-matrix .__empty-state{display:flex;align-items:center;justify-content:center;padding:calc(var(--spacing, .25rem) * 8);font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));color:rgb(var(--ax-sys-color-on-light-surface))}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], ctorParameters: () => [], propDecorators: { axisMapping: [{ type: i0.Input, args: [{ isSignal: true, alias: "axisMapping", required: false }] }], likelihoodIds: [{ type: i0.Input, args: [{ isSignal: true, alias: "likelihoodIds", required: false }] }], severityIds: [{ type: i0.Input, args: [{ isSignal: true, alias: "severityIds", required: false }] }], matrixOrientation: [{ type: i0.Input, args: [{ isSignal: true, alias: "matrixOrientation", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }], readonly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readonly", required: false }] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }], cellChange: [{ type: i0.Output, args: ["cellChange"] }] } });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Risk Matrix Viewer Service   ----
+/**
+ * Opens a read-only risk matrix preview dialog from row or record context.
+ */
+class AXMRiskMatrixViewerService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.layoutBuilder = inject(AXPLayoutBuilderService);
+        this.translation = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    async open(options) {
+        const matrixPath = defaultTo(options.matrixPath, 'matrix');
+        const matrixValue = get(options.context, matrixPath);
+        if (isEmpty(matrixValue)) {
+            return;
+        }
+        const ref = await this.layoutBuilder
+            .create()
+            .dialog((dialog) => {
+            dialog
+                .setTitle(this.resolveDialogTitle(options.title))
+                .setSize('lg')
+                .setCloseButton(true)
+                .setContext({ ...options.context })
+                .content((layout) => {
+                layout.flex((flex) => {
+                    flex.setDirection('column');
+                    flex.formField('', (field) => {
+                        field
+                            .path(matrixPath)
+                            .setShowLabel(false)
+                            .customWidget(AXPWidgetsList.Editors.RiskMatrix, { readonly: true });
+                    });
+                });
+            })
+                .setActions((actions) => {
+                actions.cancel('@general:actions.close.title');
+            });
+        })
+            .show();
+        ref.close();
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    resolveDialogTitle(title) {
+        const resolved = resolveEntityRowDisplayText(title, this.translation.getActiveLang());
+        return resolved || 'Risk Matrix';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixViewerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixViewerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixViewerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Viewer Open Helper   ----
+function buildRiskMatrixViewerOpenOptions(params) {
+    const matrixPath = params.matrixPath ?? 'matrix';
+    const title = params.data
+        ? resolveEntityRowDisplayTitle({
+            data: params.data,
+            widgetOptions: params.widgetOptions,
+            formatService: params.formatService,
+            activeLang: params.activeLang,
+            entity: params.entity,
+        })
+        : '';
+    return {
+        context: params.context,
+        matrixPath,
+        title: title || params.fallbackTitleKey,
+    };
+}
+async function openRiskMatrixViewer(viewer, params) {
+    await viewer.open(buildRiskMatrixViewerOpenOptions(params));
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Component: Risk Matrix Widget Column   ----
+class AXMRiskMatrixWidgetColumnComponent extends AXPColumnWidgetComponent {
+    constructor() {
+        super(...arguments);
+        //#region ----   Services & Dependencies   ----
+        this.riskMatrixViewer = inject(AXMRiskMatrixViewerService);
+        this.formatService = inject(AXFormatService);
+        this.translation = inject(AXTranslationService);
+    }
+    //#endregion
+    //#region ----   UI Handlers   ----
+    hasMatrix() {
+        return !isEmpty(this.rawValue);
+    }
+    async showPopup() {
+        const rowData = this.rowData;
+        if (!rowData || isEmpty(this.rawValue)) {
+            return;
+        }
+        await openRiskMatrixViewer(this.riskMatrixViewer, {
+            context: rowData,
+            matrixPath: this.path,
+            data: rowData,
+            widgetOptions: { ...this.options },
+            formatService: this.formatService,
+            activeLang: this.translation.getActiveLang(),
+            fallbackTitleKey: '@risk-management:risk-matrix-cells.entities.risk-matrix-cell.fields.matrix.title',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixWidgetColumnComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMRiskMatrixWidgetColumnComponent, isStandalone: true, selector: "axm-risk-matrix-widget-column", inputs: { rawValue: "rawValue", rowData: "rowData" }, usesInheritance: true, ngImport: i0, template: `
+    <div class="flex items-center gap-2">
+      @if (hasMatrix()) {
+        <ax-button class="ax-sm" look="twotone" color="default" (click)="showPopup()">
+          <ax-icon>
+            <i class="fa-light fa-table-cells"></i>
+          </ax-icon>
+        </ax-button>
+      } @else {
+        <span>-</span>
+      }
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1$1.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: AXDecoratorModule }, { kind: "component", type: i2$1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixWidgetColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-risk-matrix-widget-column',
+                    imports: [AXButtonModule, AXDecoratorModule],
+                    template: `
+    <div class="flex items-center gap-2">
+      @if (hasMatrix()) {
+        <ax-button class="ax-sm" look="twotone" color="default" (click)="showPopup()">
+          <ax-icon>
+            <i class="fa-light fa-table-cells"></i>
+          </ax-icon>
+        </ax-button>
+      } @else {
+        <span>-</span>
+      }
+    </div>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    inputs: ['rawValue', 'rowData'],
+                }]
+        }] });
+
+var riskMatrixWidgetColumn_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMRiskMatrixWidgetColumnComponent: AXMRiskMatrixWidgetColumnComponent
+});
+
+//#endregion
+//#region ----   Component Definition   ----
+class AXMRiskMatrixWidgetEditComponent extends AXPValueWidgetComponent {
+    //#region ----   Lifecycle Methods   ----
+    constructor() {
+        super();
+        //#endregion
+        //#region ----   Computed Properties   ----
+        this.readonly = computed(() => {
+            const options = this.options();
+            return options?.['readonly'] ?? false;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        this.axisMapping = computed(() => {
+            this.contextService.changeEvent();
+            const options = this.options();
+            const orientation = get(this.contextService.data(), 'matrixOrientation');
+            return resolveRiskMatrixAxisMappingFromOrientation(orientation, {
+                rowProperty: options?.['rowProperty'],
+                columnProperty: options?.['columnProperty'],
+                depthProperty: options?.['depthProperty'],
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "axisMapping" }] : /* istanbul ignore next */ []));
+        this.matrixOrientation = computed(() => {
+            this.contextService.changeEvent();
+            return resolveRiskMatrixOrientation(get(this.contextService.data(), 'matrixOrientation'));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixOrientation" }] : /* istanbul ignore next */ []));
+        this.likelihoodIds = computed(() => {
+            this.contextService.changeEvent();
+            return this.normalizeAxisIds(get(this.contextService.data(), 'likelihoodId'));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "likelihoodIds" }] : /* istanbul ignore next */ []));
+        this.severityIds = computed(() => {
+            this.contextService.changeEvent();
+            return this.normalizeAxisIds(get(this.contextService.data(), 'severityId'));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "severityIds" }] : /* istanbul ignore next */ []));
+        this.matrixValue = computed(() => {
+            return this.getValue() || {};
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixValue" }] : /* istanbul ignore next */ []));
+        effect(() => {
+            const likelihoodIds = this.likelihoodIds();
+            const severityIds = this.severityIds();
+            const matrix = this.getValue() ?? {};
+            const prunedMatrix = pruneMatrixToAxes(matrix, likelihoodIds, severityIds);
+            if (!isEqual(matrix, prunedMatrix)) {
+                this.setValue(prunedMatrix);
+            }
+        });
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    handleValueChange(data) {
+        if (data) {
+            this.setValue(data);
+        }
+    }
+    normalizeAxisIds(value) {
+        return normalizeRiskMatrixAxisIds(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixWidgetEditComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.8", type: AXMRiskMatrixWidgetEditComponent, isStandalone: true, selector: "axm-risk-matrix-widget-edit", host: { classAttribute: "block w-full" }, usesInheritance: true, ngImport: i0, template: `
+    <axm-risk-matrix
+      [axisMapping]="axisMapping()"
+      [matrixOrientation]="matrixOrientation()"
+      [likelihoodIds]="likelihoodIds()"
+      [severityIds]="severityIds()"
+      [value]="matrixValue()"
+      [readonly]="readonly()"
+      (valueChange)="handleValueChange($any($event))"
+    ></axm-risk-matrix>
+  `, isInline: true, dependencies: [{ kind: "component", type: AXMRiskManagementRiskMatrixComponent, selector: "axm-risk-matrix", inputs: ["axisMapping", "likelihoodIds", "severityIds", "matrixOrientation", "value", "readonly"], outputs: ["valueChange", "cellChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixWidgetEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-risk-matrix-widget-edit',
+                    standalone: true,
+                    imports: [AXMRiskManagementRiskMatrixComponent],
+                    template: `
+    <axm-risk-matrix
+      [axisMapping]="axisMapping()"
+      [matrixOrientation]="matrixOrientation()"
+      [likelihoodIds]="likelihoodIds()"
+      [severityIds]="severityIds()"
+      [value]="matrixValue()"
+      [readonly]="readonly()"
+      (valueChange)="handleValueChange($any($event))"
+    ></axm-risk-matrix>
+  `,
+                    host: {
+                        class: 'block w-full',
+                    },
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+
+var riskMatrixWidgetEdit_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMRiskMatrixWidgetEditComponent: AXMRiskMatrixWidgetEditComponent
+});
+
+//#endregion
+//#region ----   Component Definition   ----
+class AXMRiskMatrixWidgetViewComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super(...arguments);
+        //#region ----   Computed Properties   ----
+        this.axisMapping = computed(() => {
+            this.contextService.changeEvent();
+            const options = this.options();
+            const orientation = get(this.contextService.data(), 'matrixOrientation');
+            return resolveRiskMatrixAxisMappingFromOrientation(orientation, {
+                rowProperty: options?.['rowProperty'],
+                columnProperty: options?.['columnProperty'],
+                depthProperty: options?.['depthProperty'],
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "axisMapping" }] : /* istanbul ignore next */ []));
+        this.matrixOrientation = computed(() => {
+            this.contextService.changeEvent();
+            return resolveRiskMatrixOrientation(get(this.contextService.data(), 'matrixOrientation'));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixOrientation" }] : /* istanbul ignore next */ []));
+        this.likelihoodIds = computed(() => {
+            this.contextService.changeEvent();
+            return this.normalizeAxisIds(get(this.contextService.data(), 'likelihoodId'));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "likelihoodIds" }] : /* istanbul ignore next */ []));
+        this.severityIds = computed(() => {
+            this.contextService.changeEvent();
+            return this.normalizeAxisIds(get(this.contextService.data(), 'severityId'));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "severityIds" }] : /* istanbul ignore next */ []));
+        this.matrixValue = computed(() => {
+            return this.getValue() || {};
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixValue" }] : /* istanbul ignore next */ []));
+    }
+    normalizeAxisIds(value) {
+        return castArray(value)
+            .map((item) => {
+            if (item != null && typeof item === 'object' && 'id' in item) {
+                return String(item.id);
+            }
+            return item != null ? String(item) : '';
+        })
+            .filter((id) => id.length > 0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.8", type: AXMRiskMatrixWidgetViewComponent, isStandalone: true, selector: "axm-risk-matrix-widget-view", host: { classAttribute: "block w-full" }, usesInheritance: true, ngImport: i0, template: `
+    <axm-risk-matrix
+      [axisMapping]="axisMapping()"
+      [matrixOrientation]="matrixOrientation()"
+      [likelihoodIds]="likelihoodIds()"
+      [severityIds]="severityIds()"
+      [value]="matrixValue()"
+      [readonly]="true"
+    ></axm-risk-matrix>
+  `, isInline: true, dependencies: [{ kind: "component", type: AXMRiskManagementRiskMatrixComponent, selector: "axm-risk-matrix", inputs: ["axisMapping", "likelihoodIds", "severityIds", "matrixOrientation", "value", "readonly"], outputs: ["valueChange", "cellChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMRiskMatrixWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-risk-matrix-widget-view',
+                    standalone: true,
+                    imports: [AXMRiskManagementRiskMatrixComponent],
+                    template: `
+    <axm-risk-matrix
+      [axisMapping]="axisMapping()"
+      [matrixOrientation]="matrixOrientation()"
+      [likelihoodIds]="likelihoodIds()"
+      [severityIds]="severityIds()"
+      [value]="matrixValue()"
+      [readonly]="true"
+    ></axm-risk-matrix>
+  `,
+                    host: {
+                        class: 'block w-full',
+                    },
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+
+var riskMatrixWidgetView_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMRiskMatrixWidgetViewComponent: AXMRiskMatrixWidgetViewComponent
+});
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMRiskManagementMenuProvider, AXMRiskManagementModule, AXMRiskManagementPermissionDefinitionProvider, AXMRiskManagementRiskMatrixComponent, AXMRiskMatrixViewerService, AXMRiskMatrixWidgetColumnComponent, AXMRiskMatrixWidgetEditComponent, AXMRiskMatrixWidgetViewComponent, isRiskMatrixAxisProperty, isRiskMatrixOrientation, normalizeRiskMatrixAxisIds, pruneMatrixToAxes, resolveRiskMatrixAxisMapping, resolveRiskMatrixAxisMappingFromOrientation, resolveRiskMatrixOrientation, resolveRiskMatrixTitleKey, toCanonicalMatrixData, toDisplayMatrixData, validateRiskMatrixAxisMapping };
+//# sourceMappingURL=acorex-platform-module-risk-management-client.mjs.map