@acorex/modules 21.0.0-next.74 → 21.0.0-next.76

package/fesm2022/acorex-modules-settings-management.mjs

@@ -1,2 +1,814 @@
-export { b as AXMSettingsManagementModule, a as AXMSettingsManagementPermissionKeys, c as AXPSettingsManagementMenuKeys, A as AXPSettingsViewModel } from './acorex-modules-settings-management-acorex-modules-settings-management-e5asXiK4.mjs';
+import { AXToastService } from '@acorex/components/toast';
+import { AXLocaleService } from '@acorex/core/locale';
+import { AXTranslationService } from '@acorex/core/translation';
+import * as i2 from '@acorex/platform/common';
+import { AXPSettingDefinitionProviderService, AXPSettingsService, createUnsavedChangesCanDeactivateGuard, AXP_PROTECTED_ROUTE_GUARDS, AXP_SEARCH_PROVIDER, AXP_SEARCH_DEFINITION_PROVIDER, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import * as i1 from '@acorex/platform/core';
+import { resolvePlatformScopeName, AXPDeviceService, AXPPlatformScope, AXP_MODULE_MANIFEST_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER } from '@acorex/platform/core';
+import { AXPPageStatus } from '@acorex/platform/layout/widget-core';
+import * as i0 from '@angular/core';
+import { computed, inject, Injector, NgModule } from '@angular/core';
+import { signalStore, withState, withComputed, withMethods, patchState, withHooks } from '@ngrx/signals';
+import { cloneDeep, isEqual, isNil, isEmpty, get, sortBy } from 'lodash-es';
+import { filter, merge, firstValueFrom } from 'rxjs';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
+import { AXPRootLayoutComponent } from '@acorex/platform/themes/default';
+import { ROUTES } from '@angular/router';
+import { AXPCommonMenuKeys } from '@acorex/modules/common';
+import { AXPCommandService } from '@acorex/platform/runtime';
+
+/**
+ * Filters setting groups for in-page search. When `settingSearchTextByKey` is provided (lowercased
+ * translated blobs keyed by setting name), setting matches use it; otherwise a raw key fallback is used.
+ */
+function searchSettings(groups, search, settingSearchTextByKey) {
+    const trimmed = search?.trim() ?? '';
+    if (!trimmed) {
+        return [];
+    }
+    const normalizedSearch = trimmed.toLowerCase();
+    const sectionMatchResult = [];
+    const settingMatchResult = [];
+    const processedGroups = new Set();
+    const createGroupIdentifier = (group) => `${group.name}-${group.title}`;
+    const addGroupToResult = (group, sections, resultArray) => {
+        const groupId = createGroupIdentifier(group);
+        if (!processedGroups.has(groupId)) {
+            resultArray.push({
+                ...group,
+                sections,
+                groups: [], // Exclude nested groups
+            });
+            processedGroups.add(groupId);
+        }
+    };
+    const processSections = (group, filterFn) => {
+        const matchedSections = group.sections.filter(filterFn);
+        if (matchedSections.length > 0) {
+            addGroupToResult(group, matchedSections, sectionMatchResult);
+        }
+    };
+    const processSettings = (group, filterFn) => {
+        const matchedSections = group.sections
+            .map(filterFn)
+            .filter((section) => section !== null);
+        if (matchedSections.length > 0) {
+            addGroupToResult(group, matchedSections, settingMatchResult);
+        }
+    };
+    const sectionMatches = (section) => section.name.toLowerCase().includes(normalizedSearch) ||
+        section.title.toLowerCase().includes(normalizedSearch);
+    const settingSearchBlob = (setting) => {
+        const fromIndex = settingSearchTextByKey?.[setting.name];
+        if (fromIndex) {
+            return fromIndex;
+        }
+        return [setting.name, setting.title, setting.description ?? '', ...(setting.searchTagKeys ?? [])]
+            .join(' ')
+            .toLowerCase();
+    };
+    const filterSettings = (section) => {
+        const matchedSettings = section.settings.filter((setting) => {
+            const blob = settingSearchBlob(setting);
+            return (setting.name.toLowerCase().includes(normalizedSearch) ||
+                blob.includes(normalizedSearch));
+        });
+        return matchedSettings.length > 0 ? { ...section, settings: matchedSettings } : null;
+    };
+    const processGroupRecursively = (group) => {
+        processSections(group, sectionMatches); // Match sections with all settings
+        processSettings(group, filterSettings); // Match settings within sections
+        group.groups.forEach(processGroupRecursively); // Recurse into nested groups
+    };
+    groups.forEach(processGroupRecursively);
+    return [...sectionMatchResult, ...settingMatchResult];
+}
+
+/** Delay before reload so the success toast is visible. */
+const PAGE_REFRESH_DELAY_MS = 500;
+const AXPSettingsViewModel = signalStore(withState(() => ({
+    groups: [],
+    activateGroup: undefined,
+    scope: 'U',
+    //
+    searchExpression: null,
+    settingSearchTextByKey: {},
+    //
+    previousContext: {},
+    context: {},
+    /** Synced from {@link AXPWidgetContainerComponent.isFormDirty}. */
+    formDirty: false,
+    /** Bumped after apply so the settings view can commit the container saved baseline. */
+    applySyncNonce: 0,
+    /** Suppresses container→VM dirty echo while post-save baseline sync runs. */
+    syncingBaseline: false,
+    /** Bumped after discard so the settings view can revert the container to saved. */
+    discardSyncNonce: 0,
+    //
+    status: AXPPageStatus.Processing,
+    form: null,
+})), withComputed((store, deviceService = inject(AXPDeviceService)) => ({
+    searchResults: computed(() => {
+        const q = store.searchExpression();
+        if (q == null || !q.trim()) {
+            return [];
+        }
+        return searchSettings(store.groups(), q, store.settingSearchTextByKey());
+    }),
+    hasActivateGroup: computed(() => store.activateGroup() != null),
+    showGroups: computed(() => store.activateGroup() != null && deviceService.isLarge()),
+    scopeTitle: computed(() => {
+        return `${resolvePlatformScopeName(store.scope())}.title`;
+    }),
+    scopeDescription: computed(() => {
+        return `${resolvePlatformScopeName(store.scope())}.description`;
+    }),
+    isSearching: computed(() => store.searchExpression() != null),
+    isBusy: computed(() => store.status() == AXPPageStatus.Processing),
+    isSaving: computed(() => store.status() == AXPPageStatus.Submitting),
+    isLoaded: computed(() => store.groups().length > 0),
+    isDirty: computed(() => store.formDirty()),
+})), withMethods((store, settingDefinitionService = inject(AXPSettingDefinitionProviderService), settingValueService = inject(AXPSettingsService), toastService = inject(AXToastService), translateService = inject(AXTranslationService)) => ({
+    registerForm(form) {
+        patchState(store, {
+            form: form,
+        });
+    },
+    async load(scope) {
+        patchState(store, {
+            scope: scope,
+            status: AXPPageStatus.Processing,
+        });
+        //
+        const groups = await settingDefinitionService.getListAsync(scope);
+        patchState(store, {
+            groups: groups,
+        });
+        await this.rebuildSettingSearchIndex();
+        const currentContext = await settingValueService.scope(scope).all();
+        const defaults = await settingValueService.scope(scope).defaultValues();
+        patchState(store, {
+            context: { ...defaults, ...currentContext },
+        });
+        patchState(store, {
+            previousContext: store.context(),
+            status: AXPPageStatus.Rendered,
+            formDirty: false,
+        });
+    },
+    async reload() {
+        await settingDefinitionService.reload();
+        const groups = await settingDefinitionService.getListAsync(store.scope());
+        const oldActivateGroupName = store.activateGroup()?.name;
+        patchState(store, {
+            groups: groups,
+            activateGroup: undefined,
+        });
+        if (oldActivateGroupName) {
+            this.setActivateGroupByName(oldActivateGroupName);
+        }
+        await this.rebuildSettingSearchIndex();
+    },
+    async rebuildSettingSearchIndex() {
+        const groups = store.groups();
+        const map = {};
+        const walkSections = async (sections) => {
+            for (const section of sections) {
+                for (const setting of section.settings) {
+                    const parts = [await translateService.translateAsync(setting.title)];
+                    if (setting.description) {
+                        parts.push(await translateService.translateAsync(setting.description));
+                    }
+                    if (setting.searchTagKeys?.length) {
+                        for (const key of setting.searchTagKeys) {
+                            parts.push(await translateService.translateAsync(key));
+                        }
+                    }
+                    map[setting.name] = parts.join(' ').toLowerCase();
+                }
+            }
+        };
+        const walkGroups = async (gs) => {
+            for (const g of gs) {
+                await walkSections(g.sections);
+                await walkGroups(g.groups);
+            }
+        };
+        await walkGroups(groups);
+        patchState(store, { settingSearchTextByKey: map });
+    },
+    updateContext(context) {
+        patchState(store, {
+            context,
+        });
+    },
+    setFormDirty(dirty) {
+        if (store.syncingBaseline() || store.formDirty() === dirty) {
+            return;
+        }
+        patchState(store, {
+            formDirty: dirty,
+        });
+    },
+    setSyncingBaseline(syncing) {
+        if (store.syncingBaseline() === syncing) {
+            return;
+        }
+        patchState(store, {
+            syncingBaseline: syncing,
+        });
+    },
+    setActivateGroup(group) {
+        patchState(store, {
+            activateGroup: group,
+            formDirty: false,
+        });
+    },
+    unloadActivateGroup() {
+        patchState(store, {
+            activateGroup: undefined,
+            formDirty: false,
+        });
+    },
+    setActivateGroupByName(name) {
+        const group = store.groups().find((g) => g.name === name);
+        if (group) {
+            patchState(store, {
+                activateGroup: group,
+                formDirty: false,
+            });
+        }
+    },
+    //
+    async search(expression) {
+        if (!isNil(expression) && !isEmpty(expression)) {
+            patchState(store, {
+                searchExpression: expression,
+                formDirty: false,
+            });
+        }
+        else {
+            patchState(store, {
+                searchExpression: null,
+                formDirty: false,
+            });
+        }
+    },
+    clearSearch() {
+        patchState(store, {
+            searchExpression: null,
+            formDirty: false,
+        });
+    },
+    async apply() {
+        const form = store.form();
+        if (!form || !store.isDirty()) {
+            return false;
+        }
+        form.resetErrors();
+        patchState(store, {
+            status: AXPPageStatus.Submitting,
+        });
+        try {
+            const formResult = await form.validate();
+            if (!formResult.result) {
+                patchState(store, {
+                    status: AXPPageStatus.Rendered,
+                });
+                toastService.show({
+                    color: 'danger',
+                    title: await translateService.translateAsync('@general:actions.apply.messages.invalid.title'),
+                    content: await translateService.translateAsync('@general:actions.apply.messages.invalid.message'),
+                    location: 'bottom-center',
+                    closeButton: true,
+                    timeOut: 3000,
+                    timeOutProgress: true,
+                });
+                return false;
+            }
+            const changedValues = Object.fromEntries(Object.entries(store.context()).filter(([key, value]) => !isEqual(value, store.previousContext()[key])));
+            await settingValueService.scope(store.scope()).set(changedValues);
+            const refreshByKey = await settingDefinitionService.requiresPageRefreshByKey();
+            const needsPageRefresh = Object.keys(changedValues).some((key) => refreshByKey[key]);
+            patchState(store, {
+                status: AXPPageStatus.Rendered,
+                previousContext: store.context(),
+                formDirty: false,
+                applySyncNonce: store.applySyncNonce() + 1,
+            });
+            const successTitleKey = needsPageRefresh
+                ? '@settings-management:settings.actions.apply.reload.success.title'
+                : '@settings-management:settings.actions.apply.success.title';
+            const successMessageKey = needsPageRefresh
+                ? '@settings-management:settings.actions.apply.reload.success.message'
+                : '@settings-management:settings.actions.apply.success.message';
+            toastService.show({
+                color: 'success',
+                title: await translateService.translateAsync(successTitleKey),
+                content: await translateService.translateAsync(successMessageKey),
+                location: 'bottom-center',
+                closeButton: true,
+                timeOut: needsPageRefresh ? PAGE_REFRESH_DELAY_MS : 3000,
+                timeOutProgress: true,
+            });
+            if (needsPageRefresh) {
+                setTimeout(() => location.reload(), PAGE_REFRESH_DELAY_MS);
+            }
+            return true;
+        }
+        catch {
+            patchState(store, {
+                status: AXPPageStatus.Rendered,
+            });
+            toastService.show({
+                color: 'danger',
+                title: await translateService.translateAsync('@settings-management:settings.actions.apply.error.title'),
+                content: await translateService.translateAsync('@settings-management:settings.actions.apply.error.message'),
+                location: 'bottom-center',
+                closeButton: true,
+                timeOut: 3000,
+                timeOutProgress: true,
+            });
+            return false;
+        }
+    },
+    applySavedState(context) {
+        const snapshot = cloneDeep(context);
+        patchState(store, {
+            context: snapshot,
+            previousContext: snapshot,
+            formDirty: false,
+        });
+    },
+    async discard() {
+        const form = store.form();
+        form?.resetErrors();
+        const snapshot = cloneDeep(store.previousContext());
+        patchState(store, {
+            status: AXPPageStatus.Rendered,
+            context: snapshot,
+            previousContext: snapshot,
+            formDirty: false,
+            syncingBaseline: true,
+            discardSyncNonce: store.discardSyncNonce() + 1,
+        });
+    },
+    async resetToDefault() {
+        const defaults = await settingValueService.scope(store.scope()).defaultValues();
+        patchState(store, {
+            context: defaults,
+        });
+        //
+        const result = await this.apply();
+        if (!result) {
+            this.discard();
+        }
+    },
+})), withHooks((store, settingValueService = inject(AXPSettingsService), translationService = inject(AXTranslationService), localeService = inject(AXLocaleService)) => ({
+    async onInit() {
+        //
+        settingValueService.onChanged.pipe(filter((c) => c.scope == store.scope())).subscribe((e) => {
+            e.keys.forEach((k) => {
+                const currentValue = e.values[k];
+                const contextValue = get(store.context(), k);
+                const previousValue = get(store.previousContext(), k);
+                if (!isEqual(previousValue, currentValue) || !isEqual(currentValue, contextValue)) {
+                    patchState(store, {
+                        previousContext: {
+                            ...store.previousContext(),
+                            [k]: currentValue,
+                        },
+                        context: {
+                            ...store.context(),
+                            [k]: currentValue,
+                        },
+                        formDirty: false,
+                    });
+                }
+            });
+        });
+        //
+        merge(translationService.langChanges$, localeService.profileChanged$).subscribe(async () => {
+            if (store.isLoaded()) {
+                await store.reload();
+            }
+        });
+    },
+    onDestroy() { },
+})));
+
+const AXPSettingsManagementMenuKeys = {
+    TenantApplicationSettings: 'Settings:Tenant:Application',
+};
+
+//#region ----   Permission Keys   ----
+const AXMSettingsManagementPermissionKeys = {
+    UserSettings: {
+        Management: 'SettingsManagement:Permission:UserSettings.Management',
+    },
+    TenantSettings: {
+        Management: 'SettingsManagement:Permission:TenantSettings.Management',
+    },
+};
+//#endregion
+
+//#region ----   Module Configuration   ----
+const config = {
+    i18n: 'settings-management',
+    module: 'SettingsManagement',
+};
+const RootConfig = {
+    config,
+    module: {
+        route: 'settings',
+        name: config.module,
+        title: '@settings-management:module.title',
+        icon: 'fa-light fa-gear',
+    },
+    entities: {},
+};
+//#endregion
+
+//#region ---- Contracts barrel ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Settings Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const SettingsManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    required: true,
+    // Module dependencies (optional)
+};
+//#endregion
+
+class AXPSettingSearchDefinitionProvider {
+    async provide(context) {
+        context.addDefinition('setting', 'Setting', 'setting', 'fa-solid fa-gear', 3, {
+            format: {
+                id: '{{data.name}}',
+            },
+            actions: [
+                {
+                    name: 'navigate',
+                    type: 'view',
+                    priority: 'primary',
+                },
+            ],
+        });
+    }
+}
+
+class AXPSettingSearchProvider {
+    constructor() {
+        this.settingsService = inject(AXPSettingDefinitionProviderService);
+        this.sessionService = inject(AXPSessionService);
+        this.translateService = inject(AXTranslationService);
+    }
+    async search(text) {
+        const groupsSetting = this.settingsService.getList(AXPPlatformScope.User);
+        if (groupsSetting.length == 0) {
+            groupsSetting.push(...(await this.settingsService.getListAsync(AXPPlatformScope.User)));
+        }
+        // Step 2: Flatten settings from groups
+        const allSettings = [];
+        const extractSettings = (group) => {
+            for (const section of group.sections) {
+                allSettings.push(...section.settings.map((x) => ({ ...x, group })));
+            }
+            for (const subGroup of group.groups) {
+                extractSettings(subGroup); // Recursive extraction
+            }
+        };
+        for (const group of groupsSetting) {
+            extractSettings(group);
+        }
+        const needle = text.trim().toLowerCase();
+        if (!needle) {
+            return [];
+        }
+        const translatedBlobs = await Promise.all(allSettings.map(async (setting) => {
+            const parts = [await this.translateService.translateAsync(setting.title)];
+            if (setting.description) {
+                parts.push(await this.translateService.translateAsync(setting.description));
+            }
+            if (setting.searchTagKeys?.length) {
+                for (const key of setting.searchTagKeys) {
+                    parts.push(await this.translateService.translateAsync(key));
+                }
+            }
+            return parts.join(' ').toLowerCase();
+        }));
+        const searchResults = allSettings.filter((setting, i) => translatedBlobs[i].includes(needle) || setting.name.toLowerCase().includes(needle));
+        return sortBy(searchResults.map((setting) => ({
+            title: setting.title,
+            description: setting.description,
+            group: 'setting',
+            data: setting,
+            command: {
+                name: 'navigate',
+                options: {
+                    type: 'router',
+                    options: {
+                        path: `/${this.sessionService.application?.name}/settings/user/${setting.group.name}#${setting.title}`,
+                    },
+                }
+            },
+            parent: setting.group
+                ? {
+                    title: setting.group.title,
+                    data: setting.group,
+                }
+                : undefined,
+        })), ['title']);
+    }
+}
+
+//#region ----   Settings Page Can Deactivate Guard   ----
+const axpSettingsPageCanDeactivateGuard = createUnsavedChangesCanDeactivateGuard();
+//#endregion
+
+class AXMMenuProvider {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+    }
+    async provide(context) {
+        const appName = this.sessionService.application?.name;
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+        // Add TenantApplicationSettings as a child of Administration group
+        // Administration group is created by common module's menu provider
+        context.find(AXPCommonMenuKeys.Administration).addItems([
+            { name: `${AXPSettingsManagementMenuKeys.TenantApplicationSettings}:divider`, text: '', type: 'break', priority: 998 },
+            {
+                name: AXPSettingsManagementMenuKeys.TenantApplicationSettings,
+                priority: 999,
+                text: '@settings-management:module.terms.scopes.tenant.title',
+                type: 'menu',
+                icon: 'fa-light fa-gear',
+                path: `/${appName}/settings/tenant`,
+                policy: {
+                    features: [RootConfig.module.name],
+                }
+            },
+        ]);
+    }
+}
+
+//#endregion
+//#region ---- Settings management profile sections ----
+/** Contributes settings-related sections to the user profile hub. */
+const SettingsManagementProfileSectionsHookProvider = {
+    key: 'profile-page.sections',
+    priority: 10,
+    execute: (payload) => {
+        const commandService = inject(AXPCommandService);
+        const sessionService = inject(AXPSessionService);
+        const appName = sessionService.application?.name;
+        const sections = [];
+        if (commandService.exists('settings.client-export')) {
+            sections.push({
+                id: 'export-data',
+                groupId: 'account',
+                title: '@settings-management:profile-page.sections.export-data.title',
+                description: '@settings-management:profile-page.sections.export-data.description',
+                icon: 'far fa-file-export',
+                priority: 30,
+                layout: { colSpan: 6 },
+                actions: [
+                    {
+                        name: 'export-local-data',
+                        title: '@settings-management:profile-page.sections.export-data.actions.manage',
+                        icon: 'far fa-download',
+                        command: { name: 'settings.client-export' },
+                    },
+                ],
+            });
+        }
+        if (appName) {
+            sections.push({
+                id: 'all-preferences',
+                groupId: 'account',
+                title: '@settings-management:profile-page.sections.all-preferences.title',
+                description: '@settings-management:profile-page.sections.all-preferences.description',
+                icon: 'far fa-sliders',
+                priority: 40,
+                layout: { colSpan: 6 },
+                actions: [
+                    {
+                        name: 'view-all-preferences',
+                        title: '@settings-management:profile-page.sections.all-preferences.actions.manage',
+                        icon: 'far fa-arrow-right',
+                        command: {
+                            name: 'navigate',
+                            options: { path: `/${appName}/settings/user` },
+                        },
+                    },
+                ],
+            });
+        }
+        if (!sections.length) {
+            return payload;
+        }
+        return {
+            ...payload,
+            sections: [...payload.sections, ...sections],
+        };
+    },
+};
+//#endregion
+
+//#region ---- Profile slot settings menu hook ----
+/** Registers the user settings entry in the profile dropdown. */
+const ProfileSlotSettingsMenuHookProvider = {
+    key: 'profile-slot.menu-items',
+    priority: 0,
+    execute: (payload) => {
+        const sessionService = inject(AXPSessionService);
+        const appName = sessionService.application?.name;
+        if (!appName) {
+            return payload;
+        }
+        return {
+            ...payload,
+            items: [
+                ...payload.items,
+                {
+                    name: 'settings',
+                    title: '@auth:profile.settings',
+                    icon: 'fa-light fa-gear',
+                    shortcuts: [{ keys: 'ctrl+shift+u', allowInEditableFields: true }],
+                    command: {
+                        name: 'navigate',
+                        options: {
+                            path: `/${appName}/settings/user`,
+                        },
+                    },
+                },
+            ],
+        };
+    },
+};
+//#endregion
+
+function routesFacory() {
+    let routes = [
+        {
+            path: ':app/settings/:scope',
+            canActivate: [...AXP_PROTECTED_ROUTE_GUARDS],
+            data: { tab: true },
+            loadComponent: () => {
+                return AXPRootLayoutComponent;
+            },
+            children: [
+                {
+                    path: '',
+                    loadComponent: () => import('./acorex-modules-settings-management-setting-page.component-B7wP0i5k.mjs').then((c) => c.AXPSettingPageComponent),
+                    canDeactivate: [axpSettingsPageCanDeactivateGuard],
+                    data: { reuse: true },
+                    children: [
+                        {
+                            path: ':group',
+                            loadComponent: () => import('./acorex-modules-settings-management-setting-view.component-CG-GW2yS.mjs').then((c) => c.AXPSettingsViewComponent),
+                            data: { reuse: false },
+                        },
+                    ],
+                },
+            ],
+        },
+    ];
+    return routes;
+}
+class AXMSettingsManagementModule {
+    constructor(appInitService, settingsService) {
+        appInitService.registerTask({
+            name: 'Settings',
+            statusText: '@settings-management:app-startup.loading-settings',
+            priority: 2,
+            run: async () => {
+                await settingsService.load();
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMSettingsManagementModule, deps: [{ token: i1.AXPAppStartUpService }, { token: i2.AXPSettingsService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMSettingsManagementModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMSettingsManagementModule, providers: [
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXPSettingSearchProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                useClass: AXPSettingSearchDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFacory,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useFactory: async () => {
+                    const injector = inject(Injector);
+                    const provider = (await import('./acorex-modules-settings-management-permission-definition.provider-CfCLhvZi.mjs')).AXMPermissionDefinitionProvider;
+                    return new provider(injector);
+                },
+                multi: true,
+            },
+            // Module Manifest Provider
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: SettingsManagementManifest,
+                multi: true,
+            },
+            {
+                provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                useValue: ProfileSlotSettingsMenuHookProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                useValue: SettingsManagementProfileSectionsHookProvider,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMSettingsManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXPSettingSearchProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                            useClass: AXPSettingSearchDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFacory,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useFactory: async () => {
+                                const injector = inject(Injector);
+                                const provider = (await import('./acorex-modules-settings-management-permission-definition.provider-CfCLhvZi.mjs')).AXMPermissionDefinitionProvider;
+                                return new provider(injector);
+                            },
+                            multi: true,
+                        },
+                        // Module Manifest Provider
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: SettingsManagementManifest,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                            useValue: ProfileSlotSettingsMenuHookProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER,
+                            useValue: SettingsManagementProfileSectionsHookProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i1.AXPAppStartUpService }, { type: i2.AXPSettingsService }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMSettingsManagementModule, AXMSettingsManagementPermissionKeys, AXPSettingsManagementMenuKeys, AXPSettingsViewModel, RootConfig };
 //# sourceMappingURL=acorex-modules-settings-management.mjs.map