@acorex/platform 19.0.1 → 19.1.1

package/common/lib/app/application.types.d.ts

@@ -143,6 +143,7 @@ export interface AXPEntity {
     module: string;
     name: string;
     source: string;
+    parentKey?: string;
     title: string;
     formats: {
         individual: string;

package/common/lib/common.module.d.ts

@@ -2,7 +2,7 @@ import { ModuleWithProviders } from '@angular/core';
 import { AXPAppStartUpService } from './app/app-startup.service';
 import { AXPDataSeederService } from './data';
 import { AXPErrorHandler } from './errors';
-import { AXPSettingsService } from './settings';
+import { AXPSettingValueProviderService } from './settings';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngrx/effects";
 import * as i2 from "@acorex/platform/workflow";
@@ -19,7 +19,7 @@ export declare class AXPCommonModule {
     /**
      * @ignore
      */
-    constructor(instances: any[], appInitService: AXPAppStartUpService, settingsService: AXPSettingsService, seederService: AXPDataSeederService);
+    constructor(instances: any[], appInitService: AXPAppStartUpService, settingsService: AXPSettingValueProviderService, seederService: AXPDataSeederService);
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<AXPCommonModule, never, [typeof i1.EffectsFeatureModule, typeof i2.AXPWorkflowModule, typeof i3.AXPopupModule, typeof i4.AXDateTimeModule, typeof i5.AXToastModule], [typeof i6.RouterModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AXPCommonModule>;

package/common/lib/layout/sticky.directive.d.ts

@@ -10,15 +10,19 @@ export declare class AXPStickyDirective {
     isStickyChange: EventEmitter<boolean>;
     private _isSticky;
     get isSticky(): boolean;
-    set isSticky(v: boolean);
+    set isSticky(value: boolean);
     private topOffset;
     private parentElement;
     private targetElement;
+    private mutationObserver;
     stickyParent: string | HTMLElement;
     stickyTarget: string;
     constructor(element: ElementRef<HTMLDivElement>, renderer: Renderer2, zone: NgZone, cdr: ChangeDetectorRef);
     ngAfterViewInit(): void;
+    private initSticky;
+    private updateTopOffset;
     private onParentScroll;
+    private toggleStickyClasses;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPStickyDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AXPStickyDirective, "[axpSticky]", ["axpSticky"], { "stickyClass": { "alias": "axpSticky"; "required": false; }; "stickyOffset": { "alias": "stickyOffset"; "required": false; }; "stickyParent": { "alias": "stickyParent"; "required": false; }; "stickyTarget": { "alias": "stickyTarget"; "required": false; }; }, { "isStickyChange": "isStickyChange"; }, never, never, true, never>;

package/common/lib/settings/index.d.ts

@@ -1,4 +1,5 @@
 export * from './setting-definition.provider';
 export * from './settings.provider';
 export * from './settings.service';
+export * from './setting.builder';
 export * from './settings.types';

package/common/lib/settings/setting-definition.provider.d.ts

@@ -1,19 +1,18 @@
 import { InjectionToken } from '@angular/core';
-import { AXPGroupDetails, AXPSettingDefinitionItem, AXPSettingDefinitionProviderContext } from './settings.types';
+import { AXPGroupSearchResult, AXPSettingDefinitionGroup, AXPSettingScope } from './settings.types';
+import { AXPSettingDefinitionProviderContext } from './setting.builder';
 import * as i0 from "@angular/core";
 export interface AXPSettingDefinitionProvider {
     provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
 }
-export declare const AXP_SETTING_PROVIDER: InjectionToken<AXPSettingDefinitionProvider[]>;
+export declare const AXP_SETTING_DEFINITION_PROVIDER: InjectionToken<AXPSettingDefinitionProvider[]>;
 export declare class AXPSettingDefinitionProviderService {
     private providers;
     private cache;
-    private pendingInserts;
-    private pendingAdditions;
-    items(): Promise<AXPSettingDefinitionItem[]>;
-    findGroupDetails(groupName: string): AXPGroupDetails | null;
-    private searchGroupDetails;
-    private createProviderContext;
+    items(): Promise<AXPSettingDefinitionGroup[]>;
+    defaultValues(scope?: AXPSettingScope): Record<string, unknown>;
+    findGroup(groupName: string): AXPGroupSearchResult | null;
+    private searchRecursive;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingDefinitionProviderService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingDefinitionProviderService>;
 }

package/common/lib/settings/setting.builder.d.ts

@@ -0,0 +1,45 @@
+import { AXPOptionsData } from '@acorex/platform/core';
+import { AXPWidgetTypesMap, AXPWidgetValueTransformFunction } from '@acorex/platform/layout/builder';
+import { AXPSettingDefinitionGroup, AXPSettingDefinitionSection, AXPSettingScope } from './index';
+export 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;
+}
+export 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;
+}
+export declare class AXPSettingDefinitionSectionBuilder {
+    private groupBuilder;
+    private section;
+    constructor(groupBuilder: AXPSettingDefinitionGroupBuilder, section: AXPSettingDefinitionSection);
+    addSetting(setting: {
+        key: string;
+        title: string;
+        scope: AXPSettingScope;
+        widget: {
+            type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap];
+            options?: AXPOptionsData;
+        };
+        description?: string;
+        isRequired?: boolean;
+        isInherited?: boolean;
+        isEncrypted?: boolean;
+        defaultValue?: unknown;
+        valueTransforms?: {
+            getter?: AXPWidgetValueTransformFunction;
+            setter?: AXPWidgetValueTransformFunction;
+        };
+    }): this;
+    endSection(): AXPSettingDefinitionGroupBuilder;
+}

package/common/lib/settings/settings.provider.d.ts

@@ -1,7 +1,8 @@
 import { AXPSettingValue } from "./settings.types";
 import { InjectionToken } from "@angular/core";
-export interface AXPSettingsProvider {
+export interface AXPSettingValueProvider {
     load(): Promise<AXPSettingValue[]>;
     set(key: string, value: any): Promise<void>;
+    set(values: Record<string, any>): Promise<void>;
 }
-export declare const AXP_SETTINGS_PROVIDER: InjectionToken<AXPSettingsProvider>;
+export declare const AXP_SETTING_VALUE_PROVIDER: InjectionToken<AXPSettingValueProvider>;

package/common/lib/settings/settings.service.d.ts

@@ -1,13 +1,17 @@
 import { Subject } from 'rxjs';
-import { AXPSettingValue } from './settings.types';
+import { AXPSettingChangedEvent, AXPSettingValue } from './settings.types';
 import * as i0 from "@angular/core";
-export declare class AXPSettingsService {
+export declare class AXPSettingValueProviderService {
     private readonly settingsProvider;
     private settingsCache;
-    readonly changed: Subject<AXPSettingValue>;
+    readonly onChanged: Subject<AXPSettingChangedEvent>;
     load(): Promise<AXPSettingValue[]>;
     get<T = any>(key: string): Promise<T>;
+    all(): Promise<any>;
     set<T = any>(key: string, value: T): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingsService>;
+    set<T = any>(values: Record<string, T>): Promise<void>;
+    set<T = any>(key: string, value: T): Promise<void>;
+    set<T = any>(values: Record<string, T>): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingValueProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingValueProviderService>;
 }

package/common/lib/settings/settings.types.d.ts

@@ -3,20 +3,28 @@ export interface AXPSettingValue {
     key: string;
     value: any;
 }
+export interface AXPSettingChangedEvent {
+    keys: string[];
+    values: Record<string, any>;
+    entries: AXPSettingValue[];
+}
+export type AXPSettingScope = 'C' | 'G' | 'T' | 'U';
 export interface AXPSettingDefinition {
     name: string;
     title: string;
     description?: string;
-    dataType: string;
     widget: AXPWidgetNode;
-    scope: string;
-    isRequired: boolean;
-    isInherited: boolean;
-    isEncrypted: boolean;
+    scope: AXPSettingScope;
+    isRequired?: boolean;
+    isInherited?: boolean;
+    isEncrypted?: boolean;
+    defaultValue?: unknown;
+    value?: unknown;
 }
 export interface AXPSettingDefinitionGroup {
     name: string;
     title: string;
+    icon?: string;
     description?: string;
     groups: AXPSettingDefinitionGroup[];
     sections: AXPSettingDefinitionSection[];
@@ -27,29 +35,11 @@ export interface AXPSettingDefinitionSection {
     description?: string;
     settings: AXPSettingDefinition[];
 }
-export type AXPSettingDefinitionItem = AXPSettingDefinitionGroup;
-export interface AXPGroupDetails {
+export interface AXPGroupSearchResult {
     breadcrumb: {
         name: string;
         title: string;
     }[];
     sections: AXPSettingDefinitionSection[] | null;
-    childGroups: AXPSettingDefinitionGroup[] | null;
-}
-export interface AXPSettingDefinitionFinderResult {
-    insertGroup(item: AXPSettingDefinitionGroup, position: 'before' | 'after'): void;
-    insertSingle(item: AXPSettingDefinition, position: 'before' | 'after'): void;
-    insertSingles(items: AXPSettingDefinition[], position: 'before' | 'after'): void;
-    addItems(items: AXPSettingDefinitionItem[]): void;
-    addChildSingleAt(item: AXPSettingDefinition, index: number): void;
-    addChildSingleFirst(item: AXPSettingDefinition): void;
-    addChildSingleLast(item: AXPSettingDefinition): void;
-    addChildGroupAt(item: AXPSettingDefinitionGroup, index: number): void;
-    addChildGroupFirst(item: AXPSettingDefinitionGroup): void;
-    addChildGroupLast(item: AXPSettingDefinitionGroup): void;
-}
-export interface AXPSettingDefinitionProviderContext {
-    addItems(items: AXPSettingDefinitionItem[]): void;
-    addItem(item: AXPSettingDefinitionItem): void;
-    addGroup(group: AXPSettingDefinitionGroup): void;
+    groups: AXPSettingDefinitionGroup[] | null;
 }

package/common/lib/store/common.effects.d.ts

@@ -1,12 +1,12 @@
 import { Router } from '@angular/router';
 import { Actions } from '@ngrx/effects';
-import { AXPSettingsService } from '../settings';
+import { AXPSettingValueProviderService } from '../settings';
 import * as i0 from "@angular/core";
 export declare class AXPCommonEffects {
     private actions$;
     private router;
     private settingService;
-    constructor(actions$: Actions, router: Router, settingService: AXPSettingsService);
+    constructor(actions$: Actions, router: Router, settingService: AXPSettingValueProviderService);
     command$: import("rxjs").Observable<never> & import("@ngrx/effects").CreateEffectMetadata;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonEffects, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPCommonEffects>;