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

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

@@ -0,0 +1,1097 @@
+import { AXPCommonMenuKeys, AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
+import { AXPEntityService, AXPEntityDataSelectorService, AXPEntityDefinitionRegistryService } from '@acorex-platform/framework-client/layout/entity';
+import * as i0 from '@angular/core';
+import { inject, Injectable, NgModule, DestroyRef, signal, input, output, computed, effect, ChangeDetectionStrategy, ViewEncapsulation, Component } from '@angular/core';
+import { RootConfig, AXMLearningManagementMenuKeys, AXPLearningPermissionKeys } from '@acorex-platform/module-learning-management-client/contracts';
+import { createEntityCommandOptions, AXPSearchCommandProvider, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXP_WIDGETS_EDITOR_CATEGORY, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER, AXPValueWidgetComponent } from '@acorex-platform/framework-client/layout/widget-core';
+import { AXP_MODULE_MANIFEST_PROVIDER } from '@acorex-platform/framework-client/core';
+import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+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 { AXPWidgetsList } from '@acorex-platform/framework-shared/core';
+import * as i3 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { AXPSpreadsheetComponent } from '@acorex-platform/framework-client/layout/components';
+import * as i1 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i4 from '@acorex/core/translation';
+import { AXTranslationService, resolveMultiLanguageString, AXTranslationModule } from '@acorex/core/translation';
+import { get } from 'lodash';
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Menu Provider   ----
+/**
+ * Learning Management Module Menu Provider.
+ * - Root "Learning": Skills, Courses, Trainings, Enrollments, Certificates, Licenses, Learning Paths (operational)
+ * - Configuration/Learning: Skill Levels, Course Types, Training Definitions/Types, Certificate Definitions/Types, License Types, Mandatory Training Rules (reference)
+ */
+class AXMLearningManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        // Root "Learning" - single level, direct links with dividers
+        context.addItems([
+            {
+                name: AXMLearningManagementMenuKeys.Root,
+                priority: 8210,
+                text: '@learning-management:module.menus.root.title',
+                icon: module.icon,
+                policy: {
+                    features: [module.name],
+                },
+                children: [
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:skills`,
+                        text: RootConfig.entities.skill.titlePlural,
+                        icon: RootConfig.entities.skill.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.skill.name),
+                        priority: 1,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:courses`,
+                        text: RootConfig.entities.course.titlePlural,
+                        icon: RootConfig.entities.course.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.course.name),
+                        priority: 2,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:trainings`,
+                        text: RootConfig.entities.training.titlePlural,
+                        icon: RootConfig.entities.training.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.training.name),
+                        priority: 3,
+                    },
+                    { name: `${AXMLearningManagementMenuKeys.Root}:divider1`, text: '', type: 'break', priority: 4 },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:enrollments`,
+                        text: RootConfig.entities.enrollment.titlePlural,
+                        icon: RootConfig.entities.enrollment.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.enrollment.name),
+                        priority: 5,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:attendance`,
+                        text: RootConfig.entities.attendance.titlePlural,
+                        icon: RootConfig.entities.attendance.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.attendance.name),
+                        priority: 6,
+                    },
+                    { name: `${AXMLearningManagementMenuKeys.Root}:divider2`, text: '', type: 'break', priority: 7 },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:certificates`,
+                        text: RootConfig.entities.certificate.titlePlural,
+                        icon: RootConfig.entities.certificate.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.certificate.name),
+                        priority: 8,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:licenses`,
+                        text: RootConfig.entities.license.titlePlural,
+                        icon: RootConfig.entities.license.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.license.name),
+                        priority: 9,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.Root}:learning-paths`,
+                        text: RootConfig.entities.learningPath.titlePlural,
+                        icon: RootConfig.entities.learningPath.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.learningPath.name),
+                        priority: 10,
+                    },
+                ],
+            },
+        ]);
+        // Configuration/Learning - reference data
+        context.find(AXPCommonMenuKeys.Configuration).addItems([
+            {
+                name: AXMLearningManagementMenuKeys.ConfigurationRoot,
+                priority: 8650,
+                text: '@learning-management:module.menus.configuration.title',
+                icon: module.icon,
+                policy: {
+                    features: [module.name],
+                },
+                children: [
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:skill-levels`,
+                        text: RootConfig.entities.skillLevel.titlePlural,
+                        icon: RootConfig.entities.skillLevel.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.skillLevel.name),
+                        priority: 1,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:course-types`,
+                        text: RootConfig.entities.courseType.titlePlural,
+                        icon: RootConfig.entities.courseType.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.courseType.name),
+                        priority: 2,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:training-definitions`,
+                        text: RootConfig.entities.trainingDefinition.titlePlural,
+                        icon: RootConfig.entities.trainingDefinition.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.trainingDefinition.name),
+                        priority: 3,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:training-types`,
+                        text: RootConfig.entities.trainingType.titlePlural,
+                        icon: RootConfig.entities.trainingType.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.trainingType.name),
+                        priority: 4,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:certificate-definitions`,
+                        text: RootConfig.entities.certificateDefinition.titlePlural,
+                        icon: RootConfig.entities.certificateDefinition.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.certificateDefinition.name),
+                        priority: 5,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:certificate-types`,
+                        text: RootConfig.entities.certificateType.titlePlural,
+                        icon: RootConfig.entities.certificateType.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.certificateType.name),
+                        priority: 6,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:license-types`,
+                        text: RootConfig.entities.licenseType.titlePlural,
+                        icon: RootConfig.entities.licenseType.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.licenseType.name),
+                        priority: 7,
+                    },
+                    {
+                        name: `${AXMLearningManagementMenuKeys.ConfigurationRoot}:mandatory-rules`,
+                        text: RootConfig.entities.mandatoryTrainingRule.titlePlural,
+                        icon: RootConfig.entities.mandatoryTrainingRule.icon,
+                        path: this.entityService.createPath(module.name, RootConfig.entities.mandatoryTrainingRule.name),
+                        priority: 8,
+                    },
+                ],
+            },
+        ]);
+    }
+}
+//#endregion
+
+//#endregion
+//#region ---- Permission Definition Provider ----
+/**
+ * Registers learning capabilities into the shared Learning group.
+ */
+class AXMLearningManagementPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPLearningPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:learning.permissions';
+        const G = '@common:permission-groups';
+        context
+            .addGroup(groups.Learning.Root, `${G}.learning.title`, `${G}.learning.description`, { order: 20 })
+            .addPermission(keys.Access, `${P}.access.title`, `${P}.access.description`)
+            .endPermission()
+            .addPermission(keys.MaintainLearning, `${P}.maintain-learning.title`, `${P}.maintain-learning.description`)
+            .endPermission()
+            .addPermission(keys.Setup, `${P}.setup.title`, `${P}.setup.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Search Command Provider   ----
+function cmd(id, entityKey, e, title, desc) {
+    return {
+        id,
+        group: 'command',
+        title,
+        icon: e.icon,
+        description: desc,
+        command: {
+            name: 'Entity:Create',
+            options: createEntityCommandOptions(entityKey, { name: e.name, module: RootConfig.module.name, title: e.title }),
+        },
+    };
+}
+class AXMLearningManagementSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+            cmd('create-skill', `${RootConfig.module.name}.${RootConfig.entities.skill.name}`, RootConfig.entities.skill, '@learning-management:skills.search.create-skill.title', '@learning-management:skills.search.create-skill.description'),
+            cmd('create-course', `${RootConfig.module.name}.${RootConfig.entities.course.name}`, RootConfig.entities.course, '@learning-management:courses.search.create-course.title', '@learning-management:courses.search.create-course.description'),
+            cmd('create-training', `${RootConfig.module.name}.${RootConfig.entities.training.name}`, RootConfig.entities.training, '@learning-management:trainings.search.schedule-training.title', '@learning-management:trainings.search.schedule-training.description'),
+            cmd('create-training-definition', `${RootConfig.module.name}.${RootConfig.entities.trainingDefinition.name}`, RootConfig.entities.trainingDefinition, '@learning-management:trainings.search.create-training-definition.title', '@learning-management:trainings.search.create-training-definition.description'),
+            cmd('create-enrollment', `${RootConfig.module.name}.${RootConfig.entities.enrollment.name}`, RootConfig.entities.enrollment, '@learning-management:enrollments.search.create-enrollment.title', '@learning-management:enrollments.search.create-enrollment.description'),
+            cmd('create-learning-path', `${RootConfig.module.name}.${RootConfig.entities.learningPath.name}`, RootConfig.entities.learningPath, '@learning-management:learning-paths.search.create-learning-path.title', '@learning-management:learning-paths.search.create-learning-path.description'),
+            cmd('create-certificate', `${RootConfig.module.name}.${RootConfig.entities.certificate.name}`, RootConfig.entities.certificate, '@learning-management:certificates.search.issue-certificate.title', '@learning-management:certificates.search.issue-certificate.description'),
+            cmd('create-certificate-definition', `${RootConfig.module.name}.${RootConfig.entities.certificateDefinition.name}`, RootConfig.entities.certificateDefinition, '@learning-management:certificates.search.create-certificate-definition.title', '@learning-management:certificates.search.create-certificate-definition.description'),
+            cmd('create-attendance', `${RootConfig.module.name}.${RootConfig.entities.attendance.name}`, RootConfig.entities.attendance, '@learning-management:enrollments.search.create-attendance.title', '@learning-management:enrollments.search.create-attendance.description'),
+            cmd('create-skill-level', `${RootConfig.module.name}.${RootConfig.entities.skillLevel.name}`, RootConfig.entities.skillLevel, '@learning-management:skills.search.create-skill-level.title', '@learning-management:skills.search.create-skill-level.description'),
+            cmd('create-course-type', `${RootConfig.module.name}.${RootConfig.entities.courseType.name}`, RootConfig.entities.courseType, '@learning-management:courses.search.create-course-type.title', '@learning-management:courses.search.create-course-type.description'),
+            cmd('create-training-type', `${RootConfig.module.name}.${RootConfig.entities.trainingType.name}`, RootConfig.entities.trainingType, '@learning-management:trainings.search.create-training-type.title', '@learning-management:trainings.search.create-training-type.description'),
+            cmd('create-certificate-type', `${RootConfig.module.name}.${RootConfig.entities.certificateType.name}`, RootConfig.entities.certificateType, '@learning-management:certificates.search.create-certificate-type.title', '@learning-management:certificates.search.create-certificate-type.description'),
+            cmd('create-mandatory-training-rule', `${RootConfig.module.name}.${RootConfig.entities.mandatoryTrainingRule.name}`, RootConfig.entities.mandatoryTrainingRule, '@learning-management:compliance.search.create-mandatory-training-rule.title', '@learning-management:compliance.search.create-mandatory-training-rule.description'),
+        ];
+    }
+}
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Learning Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const LearningManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'domain',
+    domain: 'assessment-learning',
+    // Module dependencies (optional)
+};
+//#endregion
+
+const AXLSkillMatrixWidget = {
+    name: 'skill-matrix-editor',
+    title: 'Skill Matrix',
+    categories: AXP_WIDGETS_EDITOR_CATEGORY,
+    groups: [AXPWidgetGroupEnum.UtilityWidget],
+    description: 'Matrix widget for managing skill levels across different skills',
+    icon: 'fa-light fa-table',
+    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 skillMatrixWidgetView_component; }).then((c) => c.AXLSkillMatrixWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return skillMatrixWidgetEdit_component; }).then((c) => c.AXLSkillMatrixWidgetEditComponent),
+        },
+    },
+};
+
+//#endregion
+//#region ----   Learning Management Widgets Provider   ----
+class AXMLearningManagementWidgetsProvider {
+    getWidgets() {
+        return [AXLSkillMatrixWidget];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementWidgetsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementWidgetsProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementWidgetsProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Module   ----
+class AXMLearningManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementModule, imports: [AXPWidgetCoreModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementModule, providers: [
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: LearningManagementManifest,
+                multi: true,
+            },
+            // Provider references (now using tokens)
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMLearningManagementPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMLearningManagementMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXMLearningManagementSearchCommandProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMLearningManagementWidgetsProvider,
+                multi: true,
+            },
+        ], imports: [AXPWidgetCoreModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWidgetCoreModule,
+                    ],
+                    providers: [
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: LearningManagementManifest,
+                            multi: true,
+                        },
+                        // Provider references (now using tokens)
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMLearningManagementPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMLearningManagementMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXMLearningManagementSearchCommandProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMLearningManagementWidgetsProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----   Imports   ----
+//#endregion
+class AXMLearningManagementSkillMatrixComponent {
+    //#endregion
+    //#region ----   Lifecycle Methods   ----
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.entityService = inject(AXPEntityService);
+        this.skillLevelDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.skillLevel.name)
+            .data();
+        this.skillDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.skill.name)
+            .data();
+        this.skillCategoryDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.skillCategory.name)
+            .data();
+        this.entityDataSelectorService = inject(AXPEntityDataSelectorService);
+        this.entityResolver = inject(AXPEntityDefinitionRegistryService);
+        this.translationService = inject(AXTranslationService);
+        this.destroyRef = inject(DestroyRef);
+        this.activeLocale = signal(this.translationService.getActiveLang(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activeLocale" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Inputs   ----
+        /**
+         * Array of job titles/positions to display as columns (e.g., Senior, Manager, Director)
+         */
+        this.titles = input([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "titles" }] : /* istanbul ignore next */ []));
+        /**
+         * Initial matrix data: { [skillId]: { [title.id]: skillLevelId } }
+         */
+        this.value = input({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether the matrix is in readonly mode
+         */
+        this.readonly = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        /**
+         * Initial skill IDs (for syncing with parent entity)
+         */
+        this.skillIds = input([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "skillIds" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Outputs   ----
+        /**
+         * Emitted when the matrix value changes
+         */
+        this.valueChange = output();
+        /**
+         * Emitted when a single cell value changes
+         */
+        this.cellChange = output();
+        /**
+         * Emitted when selected skills change (skill IDs array)
+         */
+        this.skillIdsChange = output();
+        //#endregion
+        //#region ----   Class Properties   ----
+        /**
+         * Skill levels loaded from the service
+         */
+        this.skillLevels = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "skillLevels" }] : /* istanbul ignore next */ []));
+        /**
+         * Selected skills (internal state)
+         */
+        this.selectedSkills = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedSkills" }] : /* istanbul ignore next */ []));
+        /**
+         * Skill entity definition
+         */
+        this.skillEntityDef = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "skillEntityDef" }] : /* istanbul ignore next */ []));
+        /**
+         * Loading state
+         */
+        this.isLoading = signal(true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isLoading" }] : /* istanbul ignore next */ []));
+        /**
+         * Loading state for skill entity
+         */
+        this.isLoadingSkillEntity = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "isLoadingSkillEntity" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Computed Properties   ----
+        /**
+         * Vertical titles (skills) - rows of the matrix
+         */
+        this.verticalTitles = computed(() => {
+            const locale = this.activeLocale();
+            const skills = this.selectedSkills();
+            const result = (skills ?? []).map((skill) => ({
+                id: skill.id,
+                title: resolveMultiLanguageString(skill.title, locale),
+                description: skill.description != null ? resolveMultiLanguageString(skill.description, locale) : undefined,
+            }));
+            return result;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "verticalTitles" }] : /* istanbul ignore next */ []));
+        /**
+         * Horizontal titles (job titles/positions) - columns of the matrix
+         */
+        this.horizontalTitles = computed(() => {
+            const titlesInput = this.titles();
+            const result = (titlesInput ?? []).map((title) => ({
+                id: title.id,
+                title: title.title,
+                description: title.description || undefined,
+            }));
+            return result;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "horizontalTitles" }] : /* istanbul ignore next */ []));
+        /**
+         * Cell options (skill levels) - dropdown options for each cell, loaded from service
+         */
+        this.cellOptions = computed(() => {
+            const locale = this.activeLocale();
+            const levels = this.skillLevels();
+            return (levels ?? []).map((level) => ({
+                id: level.id,
+                title: resolveMultiLanguageString(level.title, locale),
+                description: level.description != null ? resolveMultiLanguageString(level.description, locale) : undefined,
+            }));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "cellOptions" }] : /* istanbul ignore next */ []));
+        /**
+         * Spreadsheet columns - converted from horizontalTitles (job titles/positions)
+         */
+        this.spreadsheetColumns = computed(() => {
+            const horizontalTitles = this.horizontalTitles();
+            const cellOptions = this.cellOptions();
+            // Create SelectBox widget configuration for skill levels
+            const selectBoxWidget = {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'id',
+                    textField: 'title',
+                    dataSource: cellOptions.map(option => ({
+                        id: option.id,
+                        title: option.title,
+                        description: option.description,
+                    })),
+                },
+            };
+            // Convert horizontal titles to columns
+            return horizontalTitles.map((title) => ({
+                name: title.id,
+                title: title.title,
+                description: title.description,
+                path: title.id, // Path to access the value in row object
+                widget: selectBoxWidget,
+            }));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "spreadsheetColumns" }] : /* istanbul ignore next */ []));
+        /**
+         * Spreadsheet rows - converted from matrix data and vertical titles
+         */
+        this.spreadsheetRows = computed(() => {
+            const verticalTitles = this.verticalTitles();
+            const horizontalTitles = this.horizontalTitles();
+            const matrixData = this.value();
+            // Convert matrix data to spreadsheet rows
+            return verticalTitles.map((skill) => {
+                const row = {
+                    name: skill.id, // Required for fixed mode row identification
+                    _skillTitle: skill.title, // For row header display
+                    _skillDescription: skill.description, // For row header description
+                };
+                // Add cell values for each horizontal title (column)
+                horizontalTitles.forEach((title) => {
+                    const cellValue = matrixData[skill.id]?.[title.id] ?? null;
+                    row[title.id] = cellValue;
+                });
+                return row;
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "spreadsheetRows" }] : /* istanbul ignore next */ []));
+        this.translationService.langChanges$
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((lang) => this.activeLocale.set(lang));
+        // Load skill levels and skill entity definition when component initializes
+        this.loadSkillLevels();
+        this.loadSkillEntityDef();
+        // Watch for skillIds input changes and sync selected skills
+        effect(() => {
+            const ids = this.skillIds();
+            if (ids && ids.length > 0 && this.skillEntityDef()) {
+                this.loadSkillsByIds(ids);
+            }
+            else if (!ids || ids.length === 0) {
+                // Try to extract skill IDs from matrix data keys
+                const matrixData = this.value();
+                const skillIdsFromMatrix = Object.keys(matrixData || {});
+                if (skillIdsFromMatrix.length > 0 && this.skillEntityDef()) {
+                    this.loadSkillsByIds(skillIdsFromMatrix);
+                }
+                else {
+                    this.selectedSkills.set([]);
+                }
+            }
+        });
+        // Watch for matrix value changes and extract skill IDs
+        effect(() => {
+            const matrixData = this.value();
+            const currentSkillIds = this.selectedSkills().map((s) => s.id);
+            const skillIdsFromMatrix = Object.keys(matrixData || {});
+            // If matrix has skills that aren't in selectedSkills, load them
+            const missingIds = skillIdsFromMatrix.filter((id) => !currentSkillIds.includes(id));
+            if (missingIds.length > 0 && this.skillEntityDef()) {
+                this.loadSkillsByIds(missingIds);
+            }
+        });
+    }
+    //#endregion
+    //#region ----   Data Loading Methods   ----
+    /**
+     * Load skill levels from the service
+     */
+    async loadSkillLevels() {
+        try {
+            this.isLoading.set(true);
+            const query = {
+                skip: 0,
+                take: 1000,
+                sort: [{ field: 'levelNumber', dir: 'asc' }],
+            };
+            const result = await this.skillLevelDataAccessor.query(query);
+            this.skillLevels.set(result.items || []);
+        }
+        catch (error) {
+            console.error('Error loading skill levels:', error);
+            this.skillLevels.set([]);
+        }
+        finally {
+            this.isLoading.set(false);
+        }
+    }
+    /**
+     * Load skill entity definition
+     */
+    async loadSkillEntityDef() {
+        try {
+            this.isLoadingSkillEntity.set(true);
+            const entityDef = await this.entityResolver.resolve(RootConfig.module.name, RootConfig.entities.skill.name);
+            this.skillEntityDef.set(entityDef);
+        }
+        catch (error) {
+            console.error('Error loading skill entity definition:', error);
+            this.skillEntityDef.set(null);
+        }
+        finally {
+            this.isLoadingSkillEntity.set(false);
+        }
+    }
+    /**
+     * Load skills by IDs
+     */
+    async loadSkillsByIds(ids) {
+        try {
+            const skills = [];
+            for (const id of ids) {
+                try {
+                    const skill = await this.skillDataAccessor.byKey(id);
+                    if (skill) {
+                        skills.push(skill);
+                    }
+                }
+                catch (error) {
+                    console.error(`Error loading skill ${id}:`, error);
+                }
+            }
+            this.selectedSkills.set(skills);
+        }
+        catch (error) {
+            console.error('Error loading skills by IDs:', error);
+        }
+    }
+    //#endregion
+    //#region ----   Data Transformation Methods   ----
+    /**
+     * Convert spreadsheet rows back to matrix data format
+     */
+    convertSpreadsheetRowsToMatrixData(rows) {
+        const horizontalTitles = this.horizontalTitles();
+        const matrixData = {};
+        rows.forEach((row) => {
+            const skillId = row['name']; // Row identifier (skill ID)
+            if (!skillId) {
+                return;
+            }
+            matrixData[skillId] = {};
+            // Extract cell values for each column
+            horizontalTitles.forEach((title) => {
+                const cellValue = row[title.id] ?? null;
+                matrixData[skillId][title.id] = cellValue;
+            });
+        });
+        return matrixData;
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    /**
+     * Handle spreadsheet change event - convert to matrix format
+     */
+    handleSpreadsheetChange(rows) {
+        const matrixData = this.convertSpreadsheetRowsToMatrixData(rows);
+        this.valueChange.emit(matrixData);
+        // Extract skill IDs from row names and emit
+        const skillIds = rows.map((row) => row['name']).filter((id) => id != null);
+        this.skillIdsChange.emit(skillIds);
+    }
+    /**
+     * Handle cell change event from spreadsheet
+     */
+    handleCellChange(event) {
+        this.cellChange.emit(event);
+    }
+    /**
+     * Open skill selector dialog with category filter
+     */
+    async handleSelectSkills() {
+        const entityDef = this.skillEntityDef();
+        if (!entityDef) {
+            console.error('Skill entity definition not loaded');
+            return;
+        }
+        try {
+            // Get currently selected skill IDs
+            const selectedItemIds = this.selectedSkills()
+                .map((skill) => skill.id)
+                .filter((id) => id != null);
+            // Create category tree data source
+            const categoryTreeDataSource = {
+                loadRootNodes: async () => {
+                    const result = await this.skillCategoryDataAccessor.query({
+                        skip: 0,
+                        take: 1000,
+                        filter: {
+                            field: 'parentId',
+                            operator: { type: 'isEmpty' },
+                            value: true,
+                        },
+                        sort: [{ field: 'title', dir: 'asc' }],
+                    });
+                    return (result.items || []).map((item) => ({
+                        id: item.id,
+                        title: item.title || item.name,
+                        description: item.description || '',
+                        parentId: item.parentId,
+                        childrenCount: item.childrenCount || 0,
+                    }));
+                },
+                loadChildNodes: async (parentId) => {
+                    const result = await this.skillCategoryDataAccessor.query({
+                        skip: 0,
+                        take: 1000,
+                        filter: {
+                            field: 'parentId',
+                            operator: { type: 'equal' },
+                            value: parentId,
+                        },
+                        sort: [{ field: 'title', dir: 'asc' }],
+                    });
+                    return (result.items || []).map((item) => ({
+                        id: item.id,
+                        title: item.title || item.name,
+                        description: item.description || '',
+                        parentId: item.parentId,
+                        childrenCount: item.childrenCount || 0,
+                    }));
+                },
+                searchNodes: async (searchValue) => {
+                    const result = await this.skillCategoryDataAccessor.query({
+                        skip: 0,
+                        take: 1000,
+                        filter: {
+                            filters: [
+                                {
+                                    field: 'title',
+                                    operator: { type: 'contains' },
+                                    value: searchValue,
+                                },
+                                {
+                                    field: 'name',
+                                    operator: { type: 'contains' },
+                                    value: searchValue,
+                                },
+                            ],
+                            logic: 'or',
+                        },
+                    });
+                    return (result.items || []).map((item) => ({
+                        id: item.id,
+                        title: item.title || item.name,
+                        description: item.description || '',
+                        parentId: item.parentId,
+                        childrenCount: item.childrenCount || 0,
+                    }));
+                },
+            };
+            const result = await this.entityDataSelectorService.open({
+                entity: entityDef,
+                title: 'Select Skills',
+                allowMultiple: true,
+                selectedItemIds: selectedItemIds.length > 0 ? selectedItemIds : undefined,
+                columns: ['title', 'description'],
+                showCategoryFilter: false,
+                categoryFilter: {
+                    title: 'Categories',
+                    dataSource: categoryTreeDataSource,
+                    filterField: 'categoryIds',
+                    filterOperator: 'contains',
+                    width: '350px',
+                },
+            });
+            if (result && result.items && result.items.length > 0) {
+                // Update selected skills
+                this.selectedSkills.set(result.items);
+                // Emit skill IDs change
+                const skillIds = result.items.map((item) => item.id).filter((id) => id != null);
+                this.skillIdsChange.emit(skillIds);
+            }
+        }
+        catch (error) {
+            console.error('Error opening skill selector:', error);
+        }
+    }
+    /**
+     * Remove a skill from selection
+     */
+    handleRemoveSkill(skillId) {
+        const currentSkills = this.selectedSkills();
+        const updatedSkills = currentSkills.filter((skill) => skill.id !== skillId);
+        this.selectedSkills.set(updatedSkills);
+        // Remove skill data from matrix value
+        const currentMatrixData = this.value();
+        const updatedMatrixData = { ...currentMatrixData };
+        delete updatedMatrixData[skillId];
+        // Emit updated matrix data
+        this.valueChange.emit(updatedMatrixData);
+        // Emit skill IDs change
+        const skillIds = updatedSkills.map((skill) => skill.id).filter((id) => id != null);
+        this.skillIdsChange.emit(skillIds);
+    }
+    /**
+     * Handle row change event from spreadsheet (add/remove)
+     */
+    handleRowChange(event) {
+        if (event.type === 'remove') {
+            // Remove skill from selection
+            this.handleRemoveSkill(event.rowId);
+        }
+        // Note: 'add' type shouldn't happen in fixed mode, but if it does, we can handle it here
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementSkillMatrixComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMLearningManagementSkillMatrixComponent, isStandalone: true, selector: "axm-skill-matrix", inputs: { titles: { classPropertyName: "titles", publicName: "titles", 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 }, skillIds: { classPropertyName: "skillIds", publicName: "skillIds", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { valueChange: "valueChange", cellChange: "cellChange", skillIdsChange: "skillIdsChange" }, host: { classAttribute: "axm-skill-matrix" }, ngImport: i0, template: "<div class=\"__container\">\n  <div class=\"__matrix-section\">\n    <div class=\"__matrix-header ax-sm\">\n      @if (!readonly()) {\n      <ax-button color=\"primary\"\n        [text]=\"'@learning-management:skills.components.skill-matrix.actions.choose-skills.title' | translate | async\"\n        (onClick)=\"handleSelectSkills()\" [disabled]=\"isLoadingSkillEntity()\">\n        <ax-icon icon=\"far fa-plus\"></ax-icon>\n      </ax-button>\n      }\n    </div>\n    @if (isLoading()) {\n    <div class=\"__loading\">\n      <span>{{ '@learning-management:skills.components.skill-matrix.messages.loading-skill-levels' | translate | async\n        }}</span>\n    </div>\n    } @else {\n    <axp-spreadsheet [title]=\"'Skill / Level'\" [columns]=\"spreadsheetColumns()\" [rowsInput]=\"spreadsheetRows()\"\n      [rowMode]=\"'fixed'\" [readonly]=\"readonly()\" [allowRemoveRows]=\"true\" [rowTitlePath]=\"'_skillTitle'\"\n      [rowDescriptionPath]=\"'_skillDescription'\" (cellChange)=\"handleCellChange($event)\"\n      (spreadsheetChange)=\"handleSpreadsheetChange($event)\" (rowChange)=\"handleRowChange($event)\"></axp-spreadsheet>\n    }\n  </div>\n</div>", styles: [".skill-matrix{display:block;height:100%;width:100%}.skill-matrix .__container,.skill-matrix .__matrix-section{display:flex;flex-direction:column}.skill-matrix .__matrix-header{margin-bottom:calc(var(--spacing, .25rem) * 3);display:flex;justify-content:flex-end}.skill-matrix .__loading{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:var(--color-neutral-600, oklch(43.9% 0 none))}\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: AXButtonModule }, { kind: "component", type: i1.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.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMLearningManagementSkillMatrixComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-skill-matrix', standalone: true, imports: [
+                        CommonModule,
+                        AXPSpreadsheetComponent,
+                        AXButtonModule,
+                        AXDecoratorModule,
+                        AXTranslationModule,
+                    ], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        class: 'axm-skill-matrix',
+                    }, template: "<div class=\"__container\">\n  <div class=\"__matrix-section\">\n    <div class=\"__matrix-header ax-sm\">\n      @if (!readonly()) {\n      <ax-button color=\"primary\"\n        [text]=\"'@learning-management:skills.components.skill-matrix.actions.choose-skills.title' | translate | async\"\n        (onClick)=\"handleSelectSkills()\" [disabled]=\"isLoadingSkillEntity()\">\n        <ax-icon icon=\"far fa-plus\"></ax-icon>\n      </ax-button>\n      }\n    </div>\n    @if (isLoading()) {\n    <div class=\"__loading\">\n      <span>{{ '@learning-management:skills.components.skill-matrix.messages.loading-skill-levels' | translate | async\n        }}</span>\n    </div>\n    } @else {\n    <axp-spreadsheet [title]=\"'Skill / Level'\" [columns]=\"spreadsheetColumns()\" [rowsInput]=\"spreadsheetRows()\"\n      [rowMode]=\"'fixed'\" [readonly]=\"readonly()\" [allowRemoveRows]=\"true\" [rowTitlePath]=\"'_skillTitle'\"\n      [rowDescriptionPath]=\"'_skillDescription'\" (cellChange)=\"handleCellChange($event)\"\n      (spreadsheetChange)=\"handleSpreadsheetChange($event)\" (rowChange)=\"handleRowChange($event)\"></axp-spreadsheet>\n    }\n  </div>\n</div>", styles: [".skill-matrix{display:block;height:100%;width:100%}.skill-matrix .__container,.skill-matrix .__matrix-section{display:flex;flex-direction:column}.skill-matrix .__matrix-header{margin-bottom:calc(var(--spacing, .25rem) * 3);display:flex;justify-content:flex-end}.skill-matrix .__loading{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:var(--color-neutral-600, oklch(43.9% 0 none))}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], ctorParameters: () => [], propDecorators: { titles: [{ type: i0.Input, args: [{ isSignal: true, alias: "titles", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }], readonly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readonly", required: false }] }], skillIds: [{ type: i0.Input, args: [{ isSignal: true, alias: "skillIds", required: false }] }], valueChange: [{ type: i0.Output, args: ["valueChange"] }], cellChange: [{ type: i0.Output, args: ["cellChange"] }], skillIdsChange: [{ type: i0.Output, args: ["skillIdsChange"] }] } });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Component Definition   ----
+class AXLSkillMatrixWidgetEditComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super(...arguments);
+        //#endregion
+        //#region ----   Computed Properties   ----
+        /**
+         * Titles from context - reactively reads from context data signal
+         * This ensures the titles update immediately when requiredLevels changes in context
+         */
+        this.titles = computed(() => {
+            // Read directly from context data signal for reactive updates
+            const contextData = this.contextService.data();
+            const requiredLevelsFromContext = get(contextData, 'jobLevels');
+            if (Array.isArray(requiredLevelsFromContext) && requiredLevelsFromContext.length > 0) {
+                // Ensure each item has the required structure
+                return requiredLevelsFromContext.map((item) => {
+                    if (typeof item === 'string') {
+                        // If item is just a string (ID), convert to proper format
+                        return { id: item, title: item };
+                    }
+                    // If item is an object, ensure it has id and title
+                    return {
+                        id: item.id || item.value || String(item),
+                        title: item.title || item.name || String(item),
+                        description: item.description,
+                    };
+                });
+            }
+            // Fallback to options (for initial load or when context is not yet available)
+            const options = this.options();
+            const rawTitles = options?.['titles'];
+            // If titles is not set, return empty array
+            if (!rawTitles) {
+                return [];
+            }
+            // If it's already an array, return it (evaluated expression result)
+            if (Array.isArray(rawTitles)) {
+                // Ensure each item has the required structure
+                return rawTitles.map((item) => {
+                    if (typeof item === 'string') {
+                        // If item is just a string (ID), convert to proper format
+                        return { id: item, title: item };
+                    }
+                    // If item is an object, ensure it has id and title
+                    return {
+                        id: item.id || item.value || String(item),
+                        title: item.title || item.name || String(item),
+                        description: item.description,
+                    };
+                });
+            }
+            // If it's still a string (unevaluated expression), return empty array
+            // The expression will be evaluated by the widget renderer and options will update
+            if (typeof rawTitles === 'string') {
+                return [];
+            }
+            return [];
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "titles" }] : /* istanbul ignore next */ []));
+        /**
+         * Readonly mode from options - properly tracks options signal changes
+         */
+        this.readonly = computed(() => {
+            const options = this.options();
+            const result = options?.['readonly'] ?? false;
+            return result;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "readonly" }] : /* istanbul ignore next */ []));
+        /**
+         * Current matrix value - tracks getValue signal changes
+         */
+        this.matrixValue = computed(() => {
+            const result = this.getValue() || {};
+            const keysCount = Object.keys(result).length;
+            return result;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixValue" }] : /* istanbul ignore next */ []));
+        /**
+         * Skill IDs extracted from matrix data keys or from options
+         */
+        this.skillIds = computed(() => {
+            const options = this.options();
+            const skillIdsFromOptions = options?.['skillIds'] ?? [];
+            // If skillIds from options is an array, use it
+            if (Array.isArray(skillIdsFromOptions) && skillIdsFromOptions.length > 0) {
+                return skillIdsFromOptions;
+            }
+            // Otherwise, extract from matrix data keys
+            const matrixData = this.matrixValue();
+            return Object.keys(matrixData || {});
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "skillIds" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    /**
+     * Handle value change from skill-matrix component
+     */
+    handleValueChange(data) {
+        const dataKeysCount = Object.keys(data || {}).length;
+        const currentKeysCount = Object.keys(this.getValue() || {}).length;
+        if (data) {
+            this.setValue(data);
+            const afterKeysCount = Object.keys(this.getValue() || {}).length;
+        }
+        else {
+        }
+    }
+    /**
+     * Handle skill IDs change from skill-matrix component
+     * Skill IDs are stored as keys in the matrix data, so this is mainly for tracking
+     */
+    handleSkillIdsChange(skillIds) {
+        // Skill IDs are already reflected in the matrix data keys
+        // This handler is here for potential future use or side effects
+        console.log('Skill IDs changed:', skillIds);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXLSkillMatrixWidgetEditComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.8", type: AXLSkillMatrixWidgetEditComponent, isStandalone: true, selector: "axm-skill-matrix-widget-edit", host: { classAttribute: "block w-full" }, usesInheritance: true, ngImport: i0, template: `
+        <axm-skill-matrix
+            [titles]="titles()"
+            [value]="matrixValue()"
+            [skillIds]="skillIds()"
+            [readonly]="readonly()"
+            (valueChange)="handleValueChange($any($event))"
+            (skillIdsChange)="handleSkillIdsChange($any($event))"
+        ></axm-skill-matrix>
+    `, isInline: true, dependencies: [{ kind: "component", type: AXMLearningManagementSkillMatrixComponent, selector: "axm-skill-matrix", inputs: ["titles", "value", "readonly", "skillIds"], outputs: ["valueChange", "cellChange", "skillIdsChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXLSkillMatrixWidgetEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-skill-matrix-widget-edit',
+                    standalone: true,
+                    imports: [
+                        AXMLearningManagementSkillMatrixComponent
+                    ],
+                    template: `
+        <axm-skill-matrix
+            [titles]="titles()"
+            [value]="matrixValue()"
+            [skillIds]="skillIds()"
+            [readonly]="readonly()"
+            (valueChange)="handleValueChange($any($event))"
+            (skillIdsChange)="handleSkillIdsChange($any($event))"
+        ></axm-skill-matrix>
+    `,
+                    host: {
+                        class: 'block w-full',
+                    },
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+
+var skillMatrixWidgetEdit_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXLSkillMatrixWidgetEditComponent: AXLSkillMatrixWidgetEditComponent
+});
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Component Definition   ----
+class AXLSkillMatrixWidgetViewComponent extends AXPValueWidgetComponent {
+    constructor() {
+        super(...arguments);
+        //#endregion
+        //#region ----   Computed Properties   ----
+        /**
+         * Skill IDs from options
+         */
+        this.skills = computed(() => {
+            return this.options()['skills'] || [];
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "skills" }] : /* istanbul ignore next */ []));
+        /**
+         * Current matrix value
+         */
+        this.matrixValue = computed(() => {
+            return this.getValue() || {};
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "matrixValue" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----   Event Handlers   ----
+    /**
+     * Handle value change from skill-matrix component
+     */
+    handleValueChange(data) {
+        if (data) {
+            this.setValue(data);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXLSkillMatrixWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.8", type: AXLSkillMatrixWidgetViewComponent, isStandalone: true, selector: "axm-skill-matrix-widget-view", host: { classAttribute: "block w-full" }, usesInheritance: true, ngImport: i0, template: `
+        <axm-skill-matrix
+            [value]="matrixValue()"
+            [readonly]="true"
+            (valueChange)="handleValueChange($any($event))"
+        ></axm-skill-matrix>
+    `, isInline: true, dependencies: [{ kind: "component", type: AXMLearningManagementSkillMatrixComponent, selector: "axm-skill-matrix", inputs: ["titles", "value", "readonly", "skillIds"], outputs: ["valueChange", "cellChange", "skillIdsChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXLSkillMatrixWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axm-skill-matrix-widget-view',
+                    standalone: true,
+                    imports: [
+                        AXMLearningManagementSkillMatrixComponent
+                    ],
+                    template: `
+        <axm-skill-matrix
+            [value]="matrixValue()"
+            [readonly]="true"
+            (valueChange)="handleValueChange($any($event))"
+        ></axm-skill-matrix>
+    `,
+                    host: {
+                        class: 'block w-full',
+                    },
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+
+var skillMatrixWidgetView_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXLSkillMatrixWidgetViewComponent: AXLSkillMatrixWidgetViewComponent
+});
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXLSkillMatrixWidgetEditComponent, AXLSkillMatrixWidgetViewComponent, AXMLearningManagementMenuProvider, AXMLearningManagementModule, AXMLearningManagementPermissionDefinitionProvider, AXMLearningManagementSearchCommandProvider, AXMLearningManagementSkillMatrixComponent };
+//# sourceMappingURL=acorex-platform-module-learning-management-client.mjs.map