@acorex/platform 20.3.0-next.21 → 20.3.0-next.23

package/fesm2022/acorex-platform-common.mjs

@@ -1081,6 +1081,77 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: AXPErrorHandlerRegistryService }] });
 
+const AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER = new InjectionToken('AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER', {
+    factory: () => [],
+});
+
+//#region ----   Imports   ----
+//#endregion
+class AXPGlobalVariableDefinitionService {
+    constructor() {
+        //#region ----   Providers & Caches   ----
+        this.definitionProviders = inject(AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER, { optional: true }) || [];
+        /** Cache for definitions by name. */
+        this.definitionsByName = new Map();
+    }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Returns a report definition by its id.
+     * First checks the cache, then queries all providers if not found.
+     * @param name The global variable name.
+     * @returns The global variable definition if found, undefined otherwise.
+     */
+    async getByName(name) {
+        // Check cache first
+        if (this.definitionsByName.has(name)) {
+            return this.definitionsByName.get(name);
+        }
+        // Not in cache, query providers (each provider is itself a global variable definition)
+        const resolvedProviders = await Promise.all(this.definitionProviders);
+        const match = resolvedProviders.find(def => def?.name === name);
+        if (match) {
+            this.definitionsByName.set(name, match);
+            return match;
+        }
+        return undefined;
+    }
+    async execute(name) {
+        const definition = await this.getByName(name);
+        if (definition) {
+            return await definition.execute();
+        }
+        return undefined;
+    }
+    //#endregion
+    //#region ----   Cache Management   ----
+    /** Clears the definitions by name cache. */
+    clearDefinitionsCache() {
+        this.definitionsByName.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPGlobalVariableDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPGlobalVariableDefinitionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPGlobalVariableDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class AXPGlobalVariableEvaluatorScopeProvider {
+    constructor() {
+        this.globalVariableService = inject(AXPGlobalVariableDefinitionService);
+    }
+    async provide(context) {
+        context.addScope('variables', {
+            execute: async (name) => {
+                return await this.globalVariableService.execute(name);
+            }
+        });
+    }
+}
+
 class AXPStickyDirective {
     get isSticky() {
         return this._isSticky;
@@ -1225,16 +1296,355 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
                 type: Input
             }] } });
 
+//#region ----   Menu Context Builder   ----
+/**
+ * Creates a rich context for menu manipulation
+ * Similar to entity modifier context pattern
+ */
+function createMenuContext(items) {
+    const context = {
+        get items() {
+            return items;
+        },
+        find(nameOrPattern) {
+            if (typeof nameOrPattern === 'string') {
+                return context.findByName(nameOrPattern);
+            }
+            const found = context.findByPattern(nameOrPattern);
+            return found.length > 0 ? found[0] : createEmptyFinder();
+        },
+        findByName(name) {
+            return createMenuItemFinder(items, name);
+        },
+        findByPattern(pattern) {
+            const regex = typeof pattern === 'string' ? wildcardToRegex(pattern) : pattern;
+            const results = [];
+            const searchRecursive = (itemList) => {
+                for (const item of itemList) {
+                    if (item.name && regex.test(item.name)) {
+                        results.push(createMenuItemFinder(items, item.name));
+                    }
+                    if (item.children) {
+                        searchRecursive(item.children);
+                    }
+                }
+            };
+            searchRecursive(items);
+            return results;
+        },
+        add(...newItems) {
+            items.push(...newItems);
+            return context;
+        },
+        remove(predicate) {
+            removeRecursive(items, predicate);
+            return context;
+        },
+        sort() {
+            sortItemsRecursively(items);
+            return context;
+        },
+        toArray() {
+            return items;
+        },
+    };
+    return context;
+}
+//#endregion
+//#region ----   Menu Item Finder Implementation   ----
+/**
+ * Creates a finder for a specific menu item
+ */
+function createMenuItemFinder(rootItems, targetName) {
+    const findItemWithParent = (items, name, parent = { items: rootItems }) => {
+        for (const item of items) {
+            if (item.name === name) {
+                return { item, parent };
+            }
+            if (item.children) {
+                const result = findItemWithParent(item.children, name, { items: item.children });
+                if (result.item) {
+                    return result;
+                }
+            }
+        }
+        return { item: undefined, parent };
+    };
+    const finder = {
+        get() {
+            return findItemWithParent(rootItems, targetName).item;
+        },
+        exists() {
+            return finder.get() !== undefined;
+        },
+        update(updater) {
+            const { item } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const updates = typeof updater === 'function' ? updater(item) : updater;
+                Object.assign(item, updates);
+            }
+            return finder;
+        },
+        remove() {
+            const { item, parent } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const index = parent.items.indexOf(item);
+                if (index !== -1) {
+                    parent.items.splice(index, 1);
+                }
+            }
+            return finder;
+        },
+        hide() {
+            // Hide by removing the item from menu
+            return finder.remove();
+        },
+        show() {
+            // Show is a no-op since items are visible by default
+            // To truly implement show, we'd need to track removed items and re-add them
+            console.warn('show() is not fully implemented - items are visible by default');
+            return finder;
+        },
+        setPriority(priority) {
+            return finder.update({ priority });
+        },
+        addChildren(...children) {
+            const { item } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                item.children = item.children || [];
+                item.children.push(...children);
+            }
+            return finder;
+        },
+        removeChildren(predicate) {
+            const { item } = findItemWithParent(rootItems, targetName);
+            if (item && item.children) {
+                item.children = item.children.filter((c) => !predicate(c));
+            }
+            return finder;
+        },
+        moveTo(parentName) {
+            const { item, parent: oldParent } = findItemWithParent(rootItems, targetName);
+            if (!item) {
+                return finder;
+            }
+            // Remove from old parent
+            const oldIndex = oldParent.items.indexOf(item);
+            if (oldIndex !== -1) {
+                oldParent.items.splice(oldIndex, 1);
+            }
+            // Add to new parent
+            if (parentName === null) {
+                // Move to root
+                rootItems.push(item);
+            }
+            else {
+                const { item: newParentItem } = findItemWithParent(rootItems, parentName);
+                if (newParentItem) {
+                    newParentItem.children = newParentItem.children || [];
+                    newParentItem.children.push(item);
+                }
+            }
+            return finder;
+        },
+        insertBefore(...items) {
+            const { item, parent } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const index = parent.items.indexOf(item);
+                if (index !== -1) {
+                    parent.items.splice(index, 0, ...items);
+                }
+            }
+            return finder;
+        },
+        insertAfter(...items) {
+            const { item, parent } = findItemWithParent(rootItems, targetName);
+            if (item) {
+                const index = parent.items.indexOf(item);
+                if (index !== -1) {
+                    parent.items.splice(index + 1, 0, ...items);
+                }
+            }
+            return finder;
+        },
+    };
+    return finder;
+}
+/**
+ * Creates an empty finder for items not found
+ */
+function createEmptyFinder() {
+    return {
+        get: () => undefined,
+        exists: () => false,
+        update: () => createEmptyFinder(),
+        remove: () => createEmptyFinder(),
+        hide: () => createEmptyFinder(),
+        show: () => createEmptyFinder(),
+        setPriority: () => createEmptyFinder(),
+        addChildren: () => createEmptyFinder(),
+        removeChildren: () => createEmptyFinder(),
+        moveTo: () => createEmptyFinder(),
+        insertBefore: () => createEmptyFinder(),
+        insertAfter: () => createEmptyFinder(),
+    };
+}
+//#endregion
+//#region ----   Helper Functions   ----
+/**
+ * Converts wildcard pattern to regex
+ */
+function wildcardToRegex(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|\[\]\\]/g, '\\$&');
+    const regexStr = `^${escaped.replace(/\*/g, '.*')}$`;
+    return new RegExp(regexStr);
+}
+/**
+ * Recursively removes items matching predicate
+ */
+function removeRecursive(items, predicate) {
+    for (let i = items.length - 1; i >= 0; i--) {
+        const item = items[i];
+        if (predicate(item)) {
+            items.splice(i, 1);
+        }
+        else if (item.children) {
+            removeRecursive(item.children, predicate);
+        }
+    }
+}
+/**
+ * Recursively sorts items by priority
+ */
+function sortItemsRecursively(items) {
+    items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+    items.forEach((item) => {
+        if (item.children && item.children.length > 0) {
+            sortItemsRecursively(item.children);
+        }
+    });
+}
+//#endregion
+
+/**
+ * Injection token for menu middlewares (multi-provider)
+ */
+const AXP_MENU_MIDDLEWARE = new InjectionToken('AXP_MENU_MIDDLEWARE');
+//#endregion
+
+//#region ----   Menu Middleware Registry   ----
+/**
+ * Central service for managing menu middlewares with priority-based ordering
+ * Similar to token registry pattern used in identifier-management
+ */
+class AXPMenuMiddlewareRegistry {
+    constructor() {
+        //#region ----   Fields   ----
+        /**
+         * Manually registered middlewares
+         */
+        this.manualMiddlewares = new Map();
+        /**
+         * Provider-based middlewares (multi-provider injection)
+         */
+        this.providerMiddlewares = inject(AXP_MENU_MIDDLEWARE, { optional: true }) ?? [];
+    }
+    //#endregion
+    //#region ----   Registration Methods   ----
+    /**
+     * Manually register a middleware
+     * @param middleware - The middleware to register
+     */
+    register(middleware) {
+        const name = middleware.name || `middleware_${Date.now()}_${Math.random()}`;
+        const existing = this.manualMiddlewares.get(name);
+        if (!existing || (middleware.priority ?? 0) > (existing.priority ?? 0)) {
+            this.manualMiddlewares.set(name, middleware);
+        }
+    }
+    /**
+     * Unregister a middleware by name
+     * @param name - The name of the middleware to remove
+     */
+    unregister(name) {
+        this.manualMiddlewares.delete(name);
+    }
+    /**
+     * Get a specific middleware by name
+     * @param name - The middleware name
+     */
+    get(name) {
+        // Provider-provided middlewares take precedence
+        const fromProvider = this.providerMiddlewares
+            .filter((m) => m.name === name)
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))[0];
+        if (fromProvider) {
+            return fromProvider;
+        }
+        return this.manualMiddlewares.get(name);
+    }
+    /**
+     * Get all middlewares sorted by priority (highest first)
+     * Combines provider-based and manually registered middlewares
+     */
+    list() {
+        const map = new Map();
+        // Helper to add middleware, respecting priority
+        const addMiddleware = (m) => {
+            const name = m.name || `anonymous_${Date.now()}`;
+            const existing = map.get(name);
+            if (!existing || (m.priority ?? 0) > (existing.priority ?? 0)) {
+                map.set(name, m);
+            }
+        };
+        // Add provider middlewares first (higher precedence)
+        this.providerMiddlewares.forEach(addMiddleware);
+        // Add manual middlewares
+        Array.from(this.manualMiddlewares.values()).forEach(addMiddleware);
+        // Return sorted by priority (highest first)
+        return Array.from(map.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    /**
+     * Check if a middleware exists
+     * @param name - The middleware name
+     */
+    exists(name) {
+        return this.get(name) !== undefined;
+    }
+    /**
+     * Clear all manually registered middlewares
+     * Provider-based middlewares are not affected
+     */
+    clear() {
+        this.manualMiddlewares.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPMenuMiddlewareRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPMenuMiddlewareRegistry, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPMenuMiddlewareRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 const AXP_MENU_PROVIDER = new InjectionToken('AXP_MENU_PROVIDER');
 class AXPMenuProviderService {
     constructor() {
+        //#region ----   Dependencies   ----
         this.providers = inject(AXP_MENU_PROVIDER, { optional: true });
+        this.middlewareRegistry = inject(AXPMenuMiddlewareRegistry);
+        //#endregion
+        //#region ----   State   ----
         this.cache = null;
         this.pendingInserts = [];
         this.pendingRemovals = [];
         this.pendingUpdates = [];
         this.pendingAdditions = [];
     }
+    //#endregion
+    //#region ----   Public API   ----
+    /**
+     * Get menu items with middlewares applied (for end-user display)
+     */
     async items() {
         // Return cached items if available
         if (this.cache) {
@@ -1251,12 +1661,65 @@ class AXPMenuProviderService {
         this.applyPendingOperations(items);
         // Sort items by priority
         items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        // Apply middlewares using registry (sorted by priority)
+        await this.applyMiddlewares(items);
         // ADD level property to items
         setMenuItemMeta(items);
         // Cache the computed items
         this.cache = items;
         return items;
     }
+    /**
+     * Get raw menu items WITHOUT middleware applied (for management/editing)
+     * Used by menu management pages to show original items before customization
+     */
+    async rawItems() {
+        const items = [];
+        const context = this.createMenuProviderContext(items);
+        if (Array.isArray(this.providers)) {
+            for (const provider of this.providers) {
+                await provider.provide(context);
+            }
+        }
+        // Apply pending operations
+        this.applyPendingOperations(items);
+        // Sort items by priority
+        items.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+        // ADD level property to items (but NO middleware)
+        setMenuItemMeta(items);
+        return items;
+    }
+    /**
+     * Clear the cache to force reload of menu items
+     */
+    clearCache() {
+        this.cache = null;
+        this.pendingInserts = [];
+        this.pendingRemovals = [];
+        this.pendingUpdates = [];
+        this.pendingAdditions = [];
+    }
+    //#endregion
+    //#region ----   Private Methods   ----
+    /**
+     * Apply middlewares in priority order using the enhanced context API
+     */
+    async applyMiddlewares(items) {
+        const middlewares = this.middlewareRegistry.list();
+        for (const middleware of middlewares) {
+            try {
+                const context = createMenuContext(items);
+                await middleware.process(context);
+                // The context mutates the items array, so no need to reassign
+            }
+            catch (error) {
+                console.error(`Error in menu middleware ${middleware.name || 'anonymous'}:`, error);
+            }
+        }
+    }
+    /**
+     * Create provider context for menu providers
+     */
     createMenuProviderContext(items) {
         return {
             addItems: (newItems) => {
@@ -1353,14 +1816,6 @@ class AXPMenuProviderService {
         }
         return { foundItem: null, parentItems: items };
     }
-    // Method to clear the cache, if needed (e.g., when providers change)
-    clearCache() {
-        this.cache = null;
-        this.pendingInserts = [];
-        this.pendingRemovals = [];
-        this.pendingUpdates = [];
-        this.pendingAdditions = [];
-    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPMenuProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPMenuProviderService, providedIn: 'root' }); }
 }
@@ -1384,6 +1839,57 @@ function setMenuItemMeta(items, parentIndex = '', depth = 0) {
     });
 }
 
+//#region ----   Menu Middleware Provider Helper   ----
+/**
+ * Helper function to provide menu middlewares with proper DI setup
+ * Similar to provideCommandMiddleware pattern
+ *
+ * @example
+ * ```typescript
+ * // In app.config.ts or module providers
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideMenuMiddleware([
+ *       customizationMiddleware,
+ *       securityMiddleware,
+ *       loggingMiddleware
+ *     ])
+ *   ]
+ * };
+ * ```
+ */
+function provideMenuMiddleware(middlewares) {
+    return makeEnvironmentProviders([
+        ...middlewares.map((middleware) => ({
+            provide: AXP_MENU_MIDDLEWARE,
+            useValue: middleware,
+            multi: true,
+        })),
+    ]);
+}
+/**
+ * Helper to create a class-based middleware with priority
+ *
+ * @example
+ * ```typescript
+ * const myMiddleware = createMenuMiddleware({
+ *   name: 'my-middleware',
+ *   priority: 100,
+ *   process: async (context) => {
+ *     context.find('dashboard').setPriority(1);
+ *   }
+ * });
+ * ```
+ */
+function createMenuMiddleware(config) {
+    return {
+        name: config.name,
+        priority: config.priority ?? 0,
+        process: config.process,
+    };
+}
+//#endregion
+
 const AXPMenuService = signalStore({ providedIn: 'root' }, 
 // Initial State
 withState((router = inject(Router)) => {
@@ -1851,6 +2357,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+var AXPCommonSettings;
+(function (AXPCommonSettings) {
+    AXPCommonSettings["EnableOperationToasts"] = "general:notifications:enable-operation-toasts";
+})(AXPCommonSettings || (AXPCommonSettings = {}));
+
 //TODO Loading, Redirect, Drawer, Show toast
 const AXPRedirectEvent = createWorkFlowEvent('Redirect Event Fired');
 const AXPRefreshEvent = createWorkFlowEvent('Refresh Event Fired');
@@ -1903,11 +2414,10 @@ class AXPToastAction extends AXPWorkflowAction {
         super(...arguments);
         this.toastService = inject(AXToastService);
         this.translationService = inject(AXTranslationService);
+        this.settingService = inject(AXPSettingService);
     }
     async execute(context) {
-        const options = context.getVariable('options');
-        const process = options?.['process'];
-        const showResult = process?.showResult ?? true;
+        const showResult = await this.settingService.get(AXPCommonSettings.EnableOperationToasts);
         if (showResult) {
             this.toastService.show({
                 color: this.color,
@@ -2007,77 +2517,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
             type: Injectable
         }] });
 
-const AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER = new InjectionToken('AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER', {
-    factory: () => [],
-});
-
-//#region ----   Imports   ----
-//#endregion
-class AXPGlobalVariableDefinitionService {
-    constructor() {
-        //#region ----   Providers & Caches   ----
-        this.definitionProviders = inject(AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER, { optional: true }) || [];
-        /** Cache for definitions by name. */
-        this.definitionsByName = new Map();
-    }
-    //#endregion
-    //#region ----   Public API   ----
-    /**
-     * Returns a report definition by its id.
-     * First checks the cache, then queries all providers if not found.
-     * @param name The global variable name.
-     * @returns The global variable definition if found, undefined otherwise.
-     */
-    async getByName(name) {
-        // Check cache first
-        if (this.definitionsByName.has(name)) {
-            return this.definitionsByName.get(name);
-        }
-        // Not in cache, query providers (each provider is itself a global variable definition)
-        const resolvedProviders = await Promise.all(this.definitionProviders);
-        const match = resolvedProviders.find(def => def?.name === name);
-        if (match) {
-            this.definitionsByName.set(name, match);
-            return match;
-        }
-        return undefined;
-    }
-    async execute(name) {
-        const definition = await this.getByName(name);
-        if (definition) {
-            return await definition.execute();
-        }
-        return undefined;
-    }
-    //#endregion
-    //#region ----   Cache Management   ----
-    /** Clears the definitions by name cache. */
-    clearDefinitionsCache() {
-        this.definitionsByName.clear();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPGlobalVariableDefinitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPGlobalVariableDefinitionService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImport: i0, type: AXPGlobalVariableDefinitionService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AXPGlobalVariableEvaluatorScopeProvider {
-    constructor() {
-        this.globalVariableService = inject(AXPGlobalVariableDefinitionService);
-    }
-    async provide(context) {
-        context.addScope('variables', {
-            execute: async (name) => {
-                return await this.globalVariableService.execute(name);
-            }
-        });
-    }
-}
-
 class AXPCommonModule {
     static forRoot(configs) {
         return {
@@ -2160,12 +2599,21 @@ class AXPCommonModule {
                 useClass: AXPGlobalVariableEvaluatorScopeProvider,
                 multi: true,
             },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useFactory: async () => {
+                    const injector = inject(Injector);
+                    const provider = (await import('./acorex-platform-common-common-settings.provider-9OHien_H.mjs')).AXPCommonSettingProvider;
+                    return new provider(injector);
+                },
+                multi: true,
+            },
         ], imports: [AXPWorkflowModule.forChild({
                 actions: {
                     'navigate-router': AXPWorkflowRouterNavigateAction,
                     'show-prompt-dialog': AXPDialogConfirmAction,
                     'show-toast': AXPToastAction,
-                    'reload': AXPReloadAction,
+                    reload: AXPReloadAction,
                 },
                 workflows: {
                     navigate: AXPNavigateWorkflow,
@@ -2184,7 +2632,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
                                 'navigate-router': AXPWorkflowRouterNavigateAction,
                                 'show-prompt-dialog': AXPDialogConfirmAction,
                                 'show-toast': AXPToastAction,
-                                'reload': AXPReloadAction,
+                                reload: AXPReloadAction,
                             },
                             workflows: {
                                 navigate: AXPNavigateWorkflow,
@@ -2224,6 +2672,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.4", ngImpor
                             useClass: AXPGlobalVariableEvaluatorScopeProvider,
                             multi: true,
                         },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useFactory: async () => {
+                                const injector = inject(Injector);
+                                const provider = (await import('./acorex-platform-common-common-settings.provider-9OHien_H.mjs')).AXPCommonSettingProvider;
+                                return new provider(injector);
+                            },
+                            multi: true,
+                        },
                     ],
                 }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
@@ -2588,5 +3045,5 @@ class AXPVersioningService {
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGlobalVariableDefinitionService, AXPGlobalVariableEvaluatorScopeProvider, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPLogoComponent, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingService, AXPStickyDirective, AXPToastAction, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, createAllQueryView, createQueryView, getEntityInfo, provideDynamicHomePage };
+export { ALL_DEFAULT_OPERATORS, AXMWorkflowErrorHandler, AXPAppVersionService, AXPCleanNestedFilters, AXPClipBoardService, AXPCommonModule, AXPCommonSettings, AXPCustomOperatorService, AXPCustomOperatorServiceImpl, AXPDataProvider, AXPDialogConfirmAction, AXPEntityCommandScope, AXPEntityQueryType, AXPErrorHandlerRegistryService, AXPExportService, AXPFileStorageService, AXPFileStorageStatus, AXPFileTypeProviderService, AXPFilterOperatorMiddlewareService, AXPFilterOperatorMiddlewareServiceImpl, AXPFooterTextSlotComponent, AXPGlobalErrorHandler, AXPGlobalVariableDefinitionService, AXPGlobalVariableEvaluatorScopeProvider, AXPHomePageModule, AXPHomePageService, AXPLockService, AXPLogoComponent, AXPMenuMiddlewareRegistry, AXPMenuProviderService, AXPMenuSearchDefinitionProvider, AXPMenuSearchProvider, AXPMenuService, AXPNavBarSlotComponent, AXPNavigateWorkflow, AXPPlatformDefaultConfigs, AXPRedirectEvent, AXPRefreshEvent, AXPRelationshipCardinality, AXPRelationshipKind, AXPReloadAction, AXPReloadEvent, AXPSearchCommandProvider, AXPSearchDefinitionActionBuilder, AXPSearchDefinitionBuilder, AXPSearchDefinitionProviderContext, AXPSearchDefinitionProviderService, AXPSearchService, AXPSettingDefaultValuesAggregatorService, AXPSettingDefinitionGroupBuilder, AXPSettingDefinitionProviderContext, AXPSettingDefinitionProviderService, AXPSettingDefinitionSectionBuilder, AXPSettingService, AXPStickyDirective, AXPToastAction, AXPVersioningService, AXPWorkflowNavigateAction, AXPWorkflowRouterNavigateAction, AXP_APP_VERSION_PROVIDER, AXP_FILE_TYPE_INFO_PROVIDER, AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER, AXP_HOME_PAGES, AXP_HOME_PAGE_DEFAULT_KEY, AXP_MENU_MIDDLEWARE, AXP_MENU_PROVIDER, AXP_PLATFORM_CONFIG_TOKEN, AXP_ROOT_CONFIG_TOKEN, AXP_SEARCH_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_SETTING_DEFAULT_VALUES_PROVIDERS, AXP_SETTING_DEFINITION_PROVIDER, AXP_SETTING_VALUE_PROVIDER, AXVChangeType, BETWEEN_OPER, BOOLEAN_OPERATORS, CONTAINS_OPER, DATE_OPERATORS, ENDS_WITH_OPER, ENVIRONMENT, EQ_OPER, GTE_OPER, GT_OPER, IN_OPER, IS_EMPTY_OPER, IS_NOT_EMPTY_OPER, LTE_OPER, LT_OPER, NOT_CONTAINS_OPER, NOT_EQ_OPER, NUMBER_OPERATORS, STARTS_WITH_OPER, STRING_OPERATORS, configPlatform, createAllQueryView, createMenuContext, createMenuMiddleware, createQueryView, getEntityInfo, provideDynamicHomePage, provideMenuMiddleware };
 //# sourceMappingURL=acorex-platform-common.mjs.map