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

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

@@ -1,814 +1,2 @@
-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 };
+export { b as AXMSettingsManagementModule, a as AXMSettingsManagementPermissionKeys, c as AXPSettingsManagementMenuKeys, A as AXPSettingsViewModel } from './acorex-modules-settings-management-acorex-modules-settings-management-e5asXiK4.mjs';
 //# sourceMappingURL=acorex-modules-settings-management.mjs.map