@acorex/platform 20.8.7 → 20.8.8

package/common/index.d.ts

@@ -4,7 +4,7 @@ import { AXDataSourceOperator, AXStyleColorType, AXDataSourceFilterOption } from
 import * as i2 from '@acorex/components/popup';
 import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
 import * as i5 from '@acorex/platform/core';
-import { AXPValueTransformerFunctions, AXPOptionsData, AXPExpression, AXPFilterDefinition, AXPMetaData, AXPSystemActionType, AXPValidationRules, AXPGridLayoutOptions, AXPLogoConfig, AXPFileListItem, AXPNavigateActionCommand, AXPExecuteCommand, AXPApplicationUserReference, AXPEntityReference, AXPPlatformScopeKey, AXPPlatformScope, AXPWidgetTriggers, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext } from '@acorex/platform/core';
+import { AXPValueTransformerFunctions, AXPOptionsData, AXPExpression, AXPFilterDefinition, AXPMetaData, AXPSystemActionType, AXPValidationRules, AXPGridLayoutOptions, AXPLogoConfig, AXPFileListItem, AXPNavigateActionCommand, AXPExecuteCommand, AXPApplicationUserReference, AXPEntityReference, AXPPlatformScopeKey, AXPWidgetTriggers, AXPPlatformScope, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviderContext } from '@acorex/platform/core';
 import { AXPWidgetTypesMap, AXPMetaDataDefinition, AXPWidgetNode } from '@acorex/platform/layout/widget-core';
 import * as i6 from '@angular/router';
 import { Route, Routes } from '@angular/router';
@@ -1749,6 +1749,49 @@ declare abstract class AXPLockService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPLockService>;
 }
 
+declare class AXPSettingDefinitionProviderContext {
+    private rootGroups;
+    private groupMap;
+    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
+    group(name: string): AXPSettingDefinitionGroupBuilder | null;
+    getGroups(): AXPSettingDefinitionGroup[];
+    hasGroup(name: string): boolean;
+    getGroup(name: string): AXPSettingDefinitionGroup | undefined;
+}
+declare class AXPSettingDefinitionGroupBuilder {
+    private context;
+    private group;
+    constructor(context: AXPSettingDefinitionProviderContext, group: AXPSettingDefinitionGroup);
+    addSection(name: string, title: string, description?: string): AXPSettingDefinitionSectionBuilder;
+    section(name: string): AXPSettingDefinitionSectionBuilder | null;
+    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
+    endGroup(): AXPSettingDefinitionProviderContext;
+}
+declare class AXPSettingDefinitionSectionBuilder {
+    private groupBuilder;
+    private section;
+    constructor(groupBuilder: AXPSettingDefinitionGroupBuilder, section: AXPSettingDefinitionSection);
+    addSetting(setting: {
+        key: string;
+        title: string;
+        scope: AXPPlatformScopeKey;
+        widget: {
+            type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
+            options?: AXPOptionsData;
+            triggers?: AXPWidgetTriggers;
+            layout?: AXPGridLayoutOptions;
+        };
+        description?: string;
+        isRequired?: boolean;
+        isInherited?: boolean;
+        isEncrypted?: boolean;
+        defaultValue?: unknown;
+        valueTransforms?: AXPValueTransformerFunctions;
+        validationRules?: AXPValidationRules;
+    }): this;
+    endSection(): AXPSettingDefinitionGroupBuilder;
+}
+
 interface AXPSettingValueProvider {
     get scope(): AXPPlatformScope;
     load(): Promise<AXPSettingValue[]>;
@@ -1812,49 +1855,6 @@ interface AXPGroupSearchResult {
     groups: AXPSettingDefinitionGroup[] | null;
 }
 
-declare class AXPSettingDefinitionProviderContext {
-    private rootGroups;
-    private groupMap;
-    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
-    group(name: string): AXPSettingDefinitionGroupBuilder | null;
-    getGroups(): AXPSettingDefinitionGroup[];
-    hasGroup(name: string): boolean;
-    getGroup(name: string): AXPSettingDefinitionGroup | undefined;
-}
-declare class AXPSettingDefinitionGroupBuilder {
-    private context;
-    private group;
-    constructor(context: AXPSettingDefinitionProviderContext, group: AXPSettingDefinitionGroup);
-    addSection(name: string, title: string, description?: string): AXPSettingDefinitionSectionBuilder;
-    section(name: string): AXPSettingDefinitionSectionBuilder | null;
-    addGroup(name: string, title: string, description?: string, icon?: string): AXPSettingDefinitionGroupBuilder;
-    endGroup(): AXPSettingDefinitionProviderContext;
-}
-declare class AXPSettingDefinitionSectionBuilder {
-    private groupBuilder;
-    private section;
-    constructor(groupBuilder: AXPSettingDefinitionGroupBuilder, section: AXPSettingDefinitionSection);
-    addSetting(setting: {
-        key: string;
-        title: string;
-        scope: AXPPlatformScopeKey;
-        widget: {
-            type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap] | string;
-            options?: AXPOptionsData;
-            triggers?: AXPWidgetTriggers;
-            layout?: AXPGridLayoutOptions;
-        };
-        description?: string;
-        isRequired?: boolean;
-        isInherited?: boolean;
-        isEncrypted?: boolean;
-        defaultValue?: unknown;
-        valueTransforms?: AXPValueTransformerFunctions;
-        validationRules?: AXPValidationRules;
-    }): this;
-    endSection(): AXPSettingDefinitionGroupBuilder;
-}
-
 interface AXPSettingDefinitionProvider {
     provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
 }
@@ -1867,6 +1867,7 @@ declare class AXPSettingDefinitionProviderService {
     getListAsync(scope: AXPPlatformScopeKey): Promise<AXPSettingDefinitionGroup[]>;
     getList(scope: AXPPlatformScopeKey): AXPSettingDefinitionGroup[];
     defaultValues(): Promise<Record<string, unknown>>;
+    settingScopeByKey(): Promise<Record<string, AXPPlatformScope>>;
     findGroup(scope: AXPPlatformScopeKey, groupName: string): AXPGroupSearchResult;
     private searchRecursive;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingDefinitionProviderService, never>;
@@ -1904,6 +1905,7 @@ declare class AXPSettingsService implements AXPSettingsServiceInterface {
     defaultValues(scope: AXPPlatformScope): Promise<Record<string, unknown>>;
     scope(scope: AXPPlatformScope): ScopedSettingService;
     invokeChangeEvent(event: AXPSettingChangedEvent): void;
+    private seedMissingDefaults;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingsService>;
 }

package/fesm2022/acorex-platform-common.mjs

@@ -363,7 +363,8 @@ class AXPSettingDefinitionProviderService {
             return groups
                 .map((group) => ({
                 ...group,
-                sections: group.sections.map((section) => ({
+                sections: group.sections
+                    .map((section) => ({
                     ...section,
                     settings: section.settings.filter((setting) => {
                         const settingScopeIndex = scopeOrder.indexOf(setting.scope);
@@ -380,7 +381,8 @@ class AXPSettingDefinitionProviderService {
                         // 3. Exclude settings with a lower or irrelevant scope.
                         return false;
                     }),
-                })).filter((section) => section.settings.length > 0), // Keep only sections with settings
+                }))
+                    .filter((section) => section.settings.length > 0), // Keep only sections with settings
                 groups: filterByScope(group.groups, currentScope), // Recursively filter nested groups
             }))
                 .filter((group) => group.sections.length > 0 || group.groups.length > 0); // Keep groups with valid sections or nested groups
@@ -407,12 +409,33 @@ class AXPSettingDefinitionProviderService {
         collectDefaults(this.cache);
         return defaults;
     }
+    async settingScopeByKey() {
+        const scopes = {};
+        const collect = (groups) => {
+            groups.forEach((group) => {
+                group.sections.forEach((section) => {
+                    section.settings.forEach((setting) => {
+                        scopes[setting.name] = setting.scope;
+                    });
+                });
+                collect(group.groups);
+            });
+        };
+        if (!this.cache) {
+            await this.load();
+        }
+        collect(this.cache);
+        return scopes;
+    }
     findGroup(scope, groupName) {
         return this.searchRecursive(this.getList(scope), groupName, []); // Initialize with an empty breadcrumb
     }
     searchRecursive(groups, groupName, breadcrumb) {
         for (const group of groups) {
-            const currentBreadcrumb = [...breadcrumb, { name: group.name, title: group.title, description: group.description }];
+            const currentBreadcrumb = [
+                ...breadcrumb,
+                { name: group.name, title: group.title, description: group.description },
+            ];
             // If the group name matches, return its details
             if (group.name === groupName) {
                 return {
@@ -431,7 +454,7 @@ class AXPSettingDefinitionProviderService {
         return {
             breadcrumb: [],
             groups: [],
-            sections: []
+            sections: [],
         };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXPSettingDefinitionProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
@@ -482,9 +505,9 @@ const AXP_SETTING_VALUE_PROVIDER = new InjectionToken('AXP_SETTING_VALUE_PROVIDE
         return [
             new AXPSettingValueProviderDefault(AXPPlatformScope.Platform, injector),
             new AXPSettingValueProviderDefault(AXPPlatformScope.Tenant, injector),
-            new AXPSettingValueProviderDefault(AXPPlatformScope.User, injector)
+            new AXPSettingValueProviderDefault(AXPPlatformScope.User, injector),
         ];
-    }
+    },
 });
 class AXPSettingValueProviderDefault {
     constructor(_scope, injector) {
@@ -524,7 +547,7 @@ class AXPSettingValueProviderDefault {
             Object.entries(parsedSettings).forEach(([key, value]) => {
                 this.cache.set(key, value);
             });
-            return Promise.resolve(Array.from(this.cache.entries()).map(c => ({ key: c[0], value: c[1] })));
+            return Promise.resolve(Array.from(this.cache.entries()).map((c) => ({ key: c[0], value: c[1] })));
         }
         return Promise.resolve([]);
     }
@@ -569,11 +592,7 @@ class AXPSettingsService {
         this.onChanged = new Subject();
         this.onLoaded = new Subject();
         // Initialize scoped caches for dynamic scopes
-        const staticScopes = [
-            AXPPlatformScope.Platform,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.User,
-        ];
+        const staticScopes = [AXPPlatformScope.Platform, AXPPlatformScope.Tenant, AXPPlatformScope.User];
         staticScopes.forEach((scope) => {
             if (!this.scopedSettingsCache.has(scope)) {
                 this.scopedSettingsCache.set(scope, new Map());
@@ -608,6 +627,7 @@ class AXPSettingsService {
                 });
                 settingsList.push(...providerSettings);
             }
+            await this.seedMissingDefaults();
             this.onLoaded.next();
             return settingsList;
         }
@@ -620,11 +640,7 @@ class AXPSettingsService {
         if (this.scopedSettingsCache.size === 0) {
             await this.load();
         }
-        const scopeOrder = [
-            AXPPlatformScope.User,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.Platform,
-        ];
+        const scopeOrder = [AXPPlatformScope.User, AXPPlatformScope.Tenant, AXPPlatformScope.Platform];
         for (const scope of scopeOrder) {
             const scopeCache = this.scopedSettingsCache.get(scope);
             if (scopeCache && scopeCache.has(key)) {
@@ -638,11 +654,7 @@ class AXPSettingsService {
         return get(defaults, key); // Fallback if no value is found
     }
     async defaultValues(scope) {
-        let scopeOrder = [
-            AXPPlatformScope.Platform,
-            AXPPlatformScope.Tenant,
-            AXPPlatformScope.User,
-        ].reverse();
+        let scopeOrder = [AXPPlatformScope.Platform, AXPPlatformScope.Tenant, AXPPlatformScope.User].reverse();
         const scopeIndex = scopeOrder.indexOf(scope);
         if (scopeIndex === -1) {
             throw new Error(`Invalid scope: ${scope}`);
@@ -676,6 +688,32 @@ class AXPSettingsService {
         this.onChanged.next(event);
         this.eventService.publish('AXPSettingChangedEvent', event);
     }
+    async seedMissingDefaults() {
+        const definitionService = this.injector.get(AXPSettingDefinitionProviderService);
+        const aggregator = this.injector.get(AXPSettingDefaultValuesAggregatorService);
+        const [defaults, scopeByKey] = await Promise.all([
+            aggregator.getDefaults(),
+            definitionService.settingScopeByKey(),
+        ]);
+        const persistedKeysByScope = new Map(await Promise.all(this.providers.map(async (provider) => {
+            const stored = await provider.load();
+            return [provider.scope, new Set(stored.map((s) => s.key))];
+        })));
+        const toPersist = {};
+        for (const [key, value] of Object.entries(defaults)) {
+            const scope = scopeByKey[key];
+            if (!scope || value === undefined || persistedKeysByScope.get(scope)?.has(key)) {
+                continue;
+            }
+            toPersist[scope] ??= {};
+            toPersist[scope][key] = value;
+        }
+        for (const [scope, values] of Object.entries(toPersist)) {
+            if (Object.keys(values).length > 0) {
+                await this.scope(scope).set(values);
+            }
+        }
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXPSettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: AXPSettingsService, providedIn: 'root' }); }
 }