@acorex/platform 18.1.5 → 18.1.6

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

@@ -70,7 +70,7 @@ export interface AXPEntitySectionView {
 }
 export interface AXPEntityProperty {
     name: string;
-    title: string;
+    title?: string;
     description?: string;
     groupId?: string;
     reference?: {

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

@@ -1,7 +1,7 @@
 import { ModuleWithProviders } from '@angular/core';
-import { AXPErrorHandler } from './errors';
-import { Store } from '@ngrx/store';
 import { AXPAppStartUpService } from './app/app-startup.service';
+import { AXPDataSeederService } from './data';
+import { AXPErrorHandler } from './errors';
 import { AXPSettingsService } from './settings';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngrx/effects";
@@ -15,15 +15,12 @@ export interface AXPCommonModuleConfigs {
     errorHandlers: (new () => AXPErrorHandler)[];
 }
 export declare class AXPCommonModule {
-    private appInitService;
-    private store;
-    private settingsService;
     static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
     static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
     /**
      * @ignore
      */
-    constructor(instances: any[], appInitService: AXPAppStartUpService, store: Store, settingsService: AXPSettingsService);
+    constructor(instances: any[], appInitService: AXPAppStartUpService, settingsService: AXPSettingsService, seederService: AXPDataSeederService);
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<AXPCommonModule, never, [typeof i1.EffectsFeatureModule, typeof i2.StoreFeatureModule, typeof i3.AXPWorkflowModule, typeof i4.AXPopupModule, typeof i5.AXDateTimeModule, typeof i6.AXToastModule], [typeof i7.RouterModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<AXPCommonModule>;

package/common/lib/data/data-provider.types.d.ts

@@ -9,6 +9,7 @@ export declare abstract class AXPDataProvider {
     abstract deleteOne(entity: any, id: string): Promise<any>;
     abstract getFirst(entity: any): Promise<any>;
     abstract uploadFile(file: File, title: string, customUrl?: string): Promise<string>;
+    abstract updateFile(id: string, file: File, title: string, customUrl?: string): Promise<string>;
     abstract uploadMultipleFiles(files: File[], title: string): Promise<string[]>;
     abstract viewFile(id: string, name: string): Promise<Blob>;
     abstract downloadFile(id: string, name: string): Promise<Blob>;

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

@@ -0,0 +1,14 @@
+import { AXDataSourceFilterOption, AXDataSourceSortOption } from '@acorex/components/common';
+export interface AXPPagedListResult<T = any> {
+    items: T[];
+    totalCount: number;
+}
+export interface AXPQueryRequest {
+    skip: number;
+    take: number;
+    sort?: AXDataSourceSortOption[];
+    filter?: AXDataSourceFilterOption;
+    params?: {
+        [key: string]: string;
+    };
+}

package/common/lib/data/dexie-storage.service.d.ts

@@ -1,30 +1,16 @@
 import Dexie from 'dexie';
+import { AXPPagedListResult, AXPQueryRequest } from './data.types';
 import { AXPEntityStorageService } from './entity-storage-service';
-export declare class AXPDexieEntityStorageService extends Dexie implements AXPEntityStorageService {
+export declare class AXPDexieEntityStorageService extends Dexie implements AXPEntityStorageService<string, any> {
     constructor();
     get dbName(): string;
     initial<T = any>(entityName: string, collection: T[]): Promise<void>;
     getOne<T = any>(entityName: string, id: string): Promise<T>;
-    updateOne(entityName: string, id: string, keyValue: {
+    updateOne<T = any>(entityName: string, id: string, keyValue: {
         [key: string]: any;
-    }): Promise<void>;
+    }): Promise<T>;
     deleteOne(entityName: string, id: string): Promise<void>;
-    insertOne<T = any>(entityName: string, entity: T): Promise<void>;
-    getAll<T = any>(entityName: string): Promise<T[]>;
-}
-export declare class AXPDexieTableStorageService extends Dexie implements AXPEntityStorageService {
-    private schemaUpdateLock;
-    constructor();
-    private changeSchema;
-    private ensureInitialized;
-    get dbName(): string;
-    private getTable;
-    initial<T = any>(entityName: string, collection: T[]): Promise<void>;
-    getOne<T = any>(entityName: string, id: string): Promise<T>;
-    updateOne(entityName: string, id: string, keyValue: {
-        [key: string]: any;
-    }): Promise<void>;
-    deleteOne(entityName: string, id: string): Promise<void>;
-    insertOne<T = any>(entityName: string, entity: T): Promise<void>;
+    insertOne<T = any>(entityName: string, entity: T): Promise<string>;
     getAll<T = any>(entityName: string): Promise<T[]>;
+    query<T = any>(entityName: string, request: AXPQueryRequest): Promise<AXPPagedListResult<T>>;
 }

package/common/lib/data/entity-data-seeder.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface AXPDataSeeder {
+    seed(): Promise<void>;
+}
+export declare const AXP_DATA_SEEDER_TOKEN: InjectionToken<AXPDataSeeder>;
+export declare class AXPDataSeederService {
+    private loader;
+    seed(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDataSeederService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDataSeederService>;
+}

package/common/lib/data/entity-storage-service.d.ts

@@ -1,22 +1,66 @@
-export declare abstract class AXPEntityStorageService {
+import { AXPPagedListResult, AXPQueryRequest } from './data.types';
+export interface AXPEntityModel<Id> {
+    id?: Id;
+}
+export declare abstract class AXPEntityStorageService<K, T extends AXPEntityModel<K>, RCreate = Omit<T, 'id'>, RGetSingle = T, RGetList = RGetSingle> {
     abstract get dbName(): string;
-    abstract initial<T = any>(entityName: string, collection: T[]): Promise<void>;
-    abstract getOne<T = any>(entityName: string, id: string): Promise<T>;
-    abstract updateOne(entityName: string, id: string, keyValue: {
+    abstract initial(entityName: string, collection: T[]): Promise<void>;
+    abstract getOne(entityName: string, id: K): Promise<RGetSingle>;
+    abstract updateOne(entityName: string, id: K, keyValue: {
         [key: string]: any;
-    }): Promise<void>;
-    abstract deleteOne(entityName: string, id: string): Promise<void>;
-    abstract insertOne<T = any>(entityName: string, entity: T): Promise<void>;
-    abstract getAll<T = any>(entityName: string): Promise<T[]>;
+    }): Promise<RGetSingle>;
+    abstract deleteOne(entityName: string, id: K): Promise<void>;
+    abstract insertOne(entityName: string, entity: RCreate): Promise<K>;
+    abstract getAll(entityName: string): Promise<RGetList[]>;
+    abstract query(entityName: string, request: AXPQueryRequest): Promise<AXPPagedListResult<RGetList>>;
 }
-export declare abstract class AXPEntityDataProvider<T> {
+export declare abstract class AXPEntityDataProvider<K, T extends AXPEntityModel<K>, RCreate = Omit<T, 'id'>, RGetSingle = T, RGetList = RGetSingle> {
     abstract get entityName(): string;
-    abstract initial<T = any>(collection: T[]): Promise<void>;
-    abstract getOne(id: string): Promise<T>;
-    abstract getAll(): Promise<T[]>;
-    abstract updateOne(id: string, keyValue: {
+    abstract initial(collection: T[]): Promise<void>;
+    abstract getOne(id: K): Promise<RGetSingle>;
+    abstract getAll(): Promise<RGetList[]>;
+    abstract updateOne(id: K, keyValue: {
+        [key: string]: any;
+    }): Promise<RGetSingle>;
+    abstract deleteOne(id: K): Promise<void>;
+    abstract insertOne(entity: RCreate): Promise<K>;
+    abstract query(request: AXPQueryRequest): Promise<AXPPagedListResult<RGetList>>;
+}
+export declare class AXPEntityDataProviderImpl<K = any, T extends AXPEntityModel<K> = any, RCreate = Omit<T, 'id'>, RGetSingle = T, RGetList = RGetSingle> implements AXPEntityDataProvider<K, T, RCreate, RGetSingle, RGetList> {
+    private storageService;
+    entityName: string;
+    constructor(storageService: AXPEntityStorageService<K, T, RCreate, RGetSingle, RGetList>, entityName: string);
+    initial(collection: T[]): Promise<void>;
+    getOne(id: K): Promise<RGetSingle>;
+    getAll(): Promise<RGetList[]>;
+    query(request: AXPQueryRequest): Promise<AXPPagedListResult<RGetList>>;
+    updateOne(id: K, keyValue: {
+        [key: string]: any;
+    }): Promise<RGetSingle>;
+    deleteOne(id: K): Promise<void>;
+    insertOne(entity: RCreate): Promise<K>;
+}
+export declare abstract class AXMEntityCrudService<Id = string, T = any, RCreate = Omit<T, 'id'>, RGetSingle = T, RGetList = RGetSingle> {
+    abstract insertOne(request: RCreate): Promise<Id>;
+    abstract getOne(id: Id): Promise<RGetSingle>;
+    abstract deleteOne(id: Id): Promise<void>;
+    abstract updateOne(id: Id, values: {
         [key: string]: any;
     }): Promise<void>;
-    abstract deleteOne(id: string): Promise<void>;
-    abstract insertOne(entity: T): Promise<void>;
+    abstract query(request: AXPQueryRequest): Promise<AXPPagedListResult<RGetList>>;
+}
+export declare class AXMEntityCrudServiceImpl<Id, T extends AXPEntityModel<Id>, RCreate = Omit<T, 'id'>, RGetSingle = T, RGetList = RGetSingle> {
+    private entityName;
+    private _storageService;
+    private _entityDataProvider;
+    constructor(entityName: string);
+    insertOne(request: RCreate): Promise<Id>;
+    getOne(id: Id): Promise<RGetSingle>;
+    deleteOne(id: Id): Promise<void>;
+    updateOne(id: Id, values: {
+        [key: string]: any;
+    }): Promise<RGetSingle>;
+    query(request: AXPQueryRequest): Promise<AXPPagedListResult<RGetList>>;
+    get entityDataProvider(): AXPEntityDataProviderImpl<Id, T, RCreate, RGetSingle, RGetList>;
+    get storageService(): AXPEntityStorageService<any, any, any, any, any>;
 }

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

@@ -1,4 +1,5 @@
 export * from './data-provider.types';
+export * from './data.types';
 export * from './dexie-storage.service';
-export * from './entity-data-provider';
 export * from './entity-storage-service';
+export * from './entity-data-seeder';

package/common/lib/layout/menu/index.d.ts

@@ -1,2 +1,4 @@
 export * from './menu.types';
 export * from './menu.loader';
+export * from './menu.service';
+export * from './menu.provider';

package/common/lib/layout/menu/menu.provider.d.ts

@@ -0,0 +1,15 @@
+import { InjectionToken } from '@angular/core';
+import { AXPMenuInsertion, AXPMenuItem } from './menu.types';
+import * as i0 from "@angular/core";
+export interface AXPMenuProvider {
+    items(): Promise<AXPMenuInsertion[]>;
+}
+export declare const AXP_MENU_PROVIDER: InjectionToken<AXPMenuProvider>;
+export declare class AXPMenuProviderService {
+    private providers;
+    items(): Promise<AXPMenuItem[]>;
+    private applyInjections;
+    private findAndInsert;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMenuProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMenuProviderService>;
+}

package/common/lib/layout/menu/menu.service.d.ts

@@ -0,0 +1,12 @@
+import { AXPMenuItem } from './menu.types';
+export declare const AXPMenuService: import("@angular/core").Type<{
+    items: import("@angular/core").Signal<AXPMenuItem[]>;
+    selectedMenuItem: import("@angular/core").Signal<AXPMenuItem | null>;
+    setMenuItems: (items: AXPMenuItem[]) => void;
+    selectMenuItemByRoute: (path: string) => void;
+    executeCommand: (item: AXPMenuItem) => void;
+    isItemOpen: (item: AXPMenuItem) => boolean;
+} & import("@ngrx/signals").StateSource<{
+    items: AXPMenuItem[];
+    selectedMenuItem: AXPMenuItem | null;
+}>>;

package/common/lib/layout/menu/menu.types.d.ts

@@ -4,10 +4,17 @@ export interface AXPMenuItem {
     type?: 'menu' | 'group';
     name?: string;
     icon?: string;
+    priority?: number;
     opened?: boolean;
     children?: AXPMenuItem[];
-    parent?: AXPMenuItem;
     path?: string;
     command?: Action;
     data?: any;
 }
+export interface AXPMenuInsertion {
+    items: AXPMenuItem[];
+    insertAt?: {
+        target: string;
+        position?: 'after' | 'before';
+    };
+}

package/common/lib/schema/widgets/dateTime/dateTime-widget-filter.component.d.ts

@@ -5,6 +5,8 @@ import * as i0 from "@angular/core";
 export declare class AXPDateTimeWidgetFilterComponent extends AXPWidgetFilterBase {
     protected selectedItem: WritableSignal<string>;
     dataSource: string[];
+    filterFieldFrom: string;
+    filterFieldTo: string;
     private calendarService;
     private changeValueEffect;
     ngOnInit(): void;

package/common/lib/schema/widgets/lookup/lookup-widget-edit.component.d.ts

@@ -5,6 +5,7 @@ export declare class AXPLookupWidgetEditComponent extends AXPWidgetEditBase {
     protected reference: string;
     protected multiple: boolean;
     protected filterField: string;
+    protected filterValue: string;
     protected valueField: string;
     protected textField: string;
     protected template: string;

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

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

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

@@ -1,5 +1,4 @@
-import { NavigationExtras } from "@angular/router";
-import { AXPSettingValue } from "../settings";
+import { NavigationExtras } from '@angular/router';
 export declare const AXPNavigateAction: import("@ngrx/store").ActionCreator<"[Navigate] Action", (props: {
     payload: {
         commands: string | any[];
@@ -13,9 +12,3 @@ export declare const AXPNavigateAction: import("@ngrx/store").ActionCreator<"[Na
 } & import("@ngrx/store").Action<"[Navigate] Action">>;
 export declare const AXPSignOutAction: import("@ngrx/store").ActionCreator<"[SignOut] Action", () => import("@ngrx/store").Action<"[SignOut] Action">>;
 export declare const AXPSignInAction: import("@ngrx/store").ActionCreator<"[SignIn] Action", () => import("@ngrx/store").Action<"[SignIn] Action">>;
-export declare const AXPLoadSettingAction: import("@ngrx/store").ActionCreator<"[App] Load Settings", () => import("@ngrx/store").Action<"[App] Load Settings">>;
-export declare const AXPLoadSettingSuccessAction: import("@ngrx/store").ActionCreator<"[App] Load Settings Data Success", (props: {
-    data: AXPSettingValue[];
-}) => {
-    data: AXPSettingValue[];
-} & import("@ngrx/store").Action<"[App] Load Settings Data Success">>;

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

@@ -1,15 +1,12 @@
-import { Router } from "@angular/router";
-import { Actions } from "@ngrx/effects";
-import { AXPSettingsService } from "../settings";
+import { Router } from '@angular/router';
+import { Actions } from '@ngrx/effects';
+import { AXPSettingsService } 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);
-    loadInitialData$: import("rxjs").Observable<{
-        data: import("../settings").AXPSettingValue[];
-    } & import("@ngrx/store").Action<"[App] Load Settings Data Success">> & import("@ngrx/effects").CreateEffectMetadata;
     command$: import("rxjs").Observable<never> & import("@ngrx/effects").CreateEffectMetadata;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonEffects, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPCommonEffects>;

package/common/lib/workflows/common.workflow.d.ts

@@ -20,6 +20,7 @@ export declare class AXPWorkflowNavigateAction extends AXPWorkflowAction {
 }
 export declare class AXPDialogConfirmAction extends AXPWorkflowAction {
     private dialogService;
+    private translationService;
     title: string;
     message: string;
     type: AXStyleColorType;
@@ -29,6 +30,7 @@ export declare class AXPDialogConfirmAction extends AXPWorkflowAction {
 }
 export declare class AXPToastAction extends AXPWorkflowAction {
     private toastService;
+    private translationService;
     color: AXStyleColorType;
     title: string;
     content: string;

package/core/utils/data-conditioner.d.ts

@@ -1,6 +1,3 @@
-import { AXDataSourceFilterOption } from '@acorex/components/common';
+import { AXDataSourceFilterOption, AXDataSourceSortOption } from '@acorex/components/common';
 export declare function applyFilterArray(dataArray: any[], filters?: AXDataSourceFilterOption[], logic?: 'and' | 'or'): any[];
-export declare function applySortArray(dataArray: any, sorts: {
-    field: string;
-    dir: 'asc' | 'desc';
-}[]): any;
+export declare function applySortArray(dataArray: any, sorts: AXDataSourceSortOption[]): any;

package/esm2022/common/lib/app/app-startup.service.mjs

@@ -25,7 +25,7 @@ export class AXPAppStartUpService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPAppStartUpService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }] });
 function initAppFactory(appInitService) {
@@ -35,6 +35,6 @@ export const AXPAppStartUpProvider = {
     provide: APP_INITIALIZER,
     useFactory: initAppFactory,
     deps: [AXPAppStartUpService],
-    multi: true
+    multi: true,
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/app/application.types.mjs

@@ -40,4 +40,4 @@ export function resolveActionLook(tr) {
             return { color: 'primary', icon: '' };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.types.js","sourceRoot":"","sources":["../../../../../../../libs/platform/common/src/lib/app/application.types.ts"],"names":[],"mappings":"AAgBA,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC7B,2EAAW,CAAA;IACX,2EAAW,CAAA;IACX,2EAAW,CAAA;AACb,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAED,MAAM,CAAN,IAAY,0BAIX;AAJD,WAAY,0BAA0B;IACpC,mFAAQ,CAAA;IACR,qFAAS,CAAA;IACT,uFAAU,CAAA;AACZ,CAAC,EAJW,0BAA0B,KAA1B,0BAA0B,QAIrC;AAUD,MAAM,CAAN,IAAY,qBAKX;AALD,WAAY,qBAAqB;IAC/B,gDAAuB,CAAA;IACvB,8CAAqB,CAAA;IACrB,kDAAyB,CAAA;IACzB,4CAAmB,CAAA;AACrB,CAAC,EALW,qBAAqB,KAArB,qBAAqB,QAKhC;AAED,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;IACjB,mCAAa,CAAA;AACf,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B;AAmOD,MAAM,UAAU,iBAAiB,CAAC,EAAmB;IACnD,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;QAChB,KAAK,QAAQ;YACX,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QACvD,KAAK,MAAM;YACT,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QACvD,KAAK,MAAM;YACT,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;QACxD,KAAK,QAAQ;YACX,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;QACxD,KAAK,OAAO;YACV,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;QAC3D,KAAK,SAAS;YACZ,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;QACzD;YACE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAC1C,CAAC;AACH,CAAC","sourcesContent":["import { AXDataSourceOperator, AXStyleColorType } from '@acorex/components/common';\nimport { AXPOptionsData, AXPValidationRules } from '@acorex/platform/core';\nimport { AXPWidgetTypesMap } from '@acorex/platform/layout/builder';\nimport { AXPGridLayoutOptions } from '../layout';\n\nexport interface AXEntityPropertyWidget {\n  type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap];\n  path: string;\n  id?: string;\n  formula?: string;\n  children?: AXEntityPropertyWidget[];\n  mode: 'view' | 'edit' | 'designer';\n  options?: Record<string, any>;\n  triggers?: { event: string; action: string; disabled?: boolean }[];\n}\n\nexport enum AXPRelationshipKind {\n  Association,\n  Composition,\n  Aggregation,\n}\n\nexport enum AXPRelationshipCardinality {\n  OneToOne,\n  OneToMany,\n  ManyToMany,\n}\n\nexport interface AXPRelationship {\n  id: string;\n  from: string;\n  to: string;\n  kind: AXPRelationshipKind;\n  cardinality: AXPRelationshipCardinality;\n}\n\nexport enum AXPEntityCommandScope {\n  TypeLevel = 'typeLevel',\n  Selected = 'selected',\n  Individual = 'individual',\n  Section = 'section',\n}\n\nexport enum AXPEntityQueryType {\n  Single = 'single',\n  List = 'list',\n}\n\nexport interface AXPEntityPropertyLayoutConfig extends AXPGridLayoutOptions {\n  order?: number;\n}\n\nexport interface AXPEntityPropertyGroup {\n  id: string;\n  title: string;\n  description?: string;\n  permissions?: string[];\n}\n\nexport interface AXPEntityPropertyView {\n  name: string;\n  permissions?: string[];\n  layout?: AXPEntityPropertyLayoutConfig;\n}\n\nexport interface AXPEntityPropertyUpdateView extends AXPEntityPropertyView {}\n\nexport interface AXPEntityPropertyCreateView extends AXPEntityPropertyView {\n  defaultValue?: any;\n}\n\nexport interface AXPEntitySectionView {\n  id: string;\n  description?: string;\n  order?: number;\n  layout?: AXPEntityPropertyLayoutConfig;\n}\n\nexport interface AXPEntityProperty {\n  name: string;\n  title: string;\n  description?: string;\n  groupId?: string;\n  reference?: {\n    relationId: string;\n  };\n  schema: {\n    dataType: string;\n    nullable?: boolean;\n    readonly?: boolean;\n    hidden?: boolean;\n    defaultValue?: any | string | ((context: any | null) => any);\n    unique?: {\n      enabled: boolean;\n    };\n    interface?: Partial<AXEntityPropertyWidget>;\n  };\n  options?: {\n    filter?: {\n      advance?: {\n        enabled?: boolean;\n        widget?: AXPOptionsData;\n      };\n      inline?: {\n        enabled?: boolean;\n      };\n    };\n    sort?: {\n      enabled?: boolean;\n    };\n  };\n  validations?: AXPValidationRules;\n}\n\nexport interface AXPEntityTableColumn {\n  name: string;\n  title?: string;\n  options?: {\n    visible?: boolean;\n    width?: string;\n    [name: string]: any;\n  };\n}\n\nexport interface AXPEntityCommand {\n  execute: string | Function; // As runnable expression\n  permissions?: string[];\n}\n\nexport interface AXPEntityQuery {\n  execute: string | Function; // As runnable expression\n  type: AXPEntityQueryType;\n}\n\nexport interface AXPEntityHistory {}\n\nexport interface AXPEntityAction {\n  permissions?: string[];\n  command: string;\n  title: string;\n  type: 'create' | 'update' | 'delete' | 'print' | 'confirm' | 'report' | 'info' | 'view';\n  priority: 'primary' | 'secondary';\n  color?: 'primary' | 'danger' | 'success' | 'warning';\n  separated?: boolean;\n  icon?: string;\n  scope: AXPEntityCommandScope;\n}\n\nexport interface AXPEntity {\n  module: string;\n  name: string;\n  source: string;\n  title: string;\n  formats: {\n    individual: string;\n    plural: string;\n    lookup?: string;\n  };\n  relatedEntities?: AXPRelatedEntity[];\n  groups?: AXPEntityPropertyGroup[];\n  properties: AXPEntityProperty[];\n  columns?: AXPEntityTableColumn[];\n  commands?: {\n    create: AXPEntityCommand | undefined;\n    update?: AXPEntityCommand | undefined;\n    delete?: AXPEntityCommand | undefined;\n    [name: string]: AXPEntityCommand | undefined;\n  };\n  queries: {\n    byKey: AXPEntityQuery;\n    list?: AXPEntityQuery;\n    lookup?: AXPEntityQuery;\n    history?: AXPEntityQuery;\n    comments?: AXPEntityQuery;\n    [name: string]: AXPEntityQuery | undefined;\n  };\n  validations?: AXPValidationRules;\n  interfaces?: {\n    master?: {\n      single?: AXPEntityMasterSingleLayoutView;\n      list?: AXPEntityMasterListView;\n      create?: AXPEntityMasterCreateLayoutView;\n      update?: AXPEntityMasterUpdateLayoutView;\n    };\n    detail?: {\n      list?: AXPEntityDetailListView;\n    };\n  };\n}\n\nexport interface AXPRelatedEntity {\n  entity: string;\n  title?: string;\n  columns?: string[];\n  conditions?: AXPQueryFilter[];\n  sorts?: AXPQuerySort[];\n}\n\nexport interface AXPAggregate {\n  id: string;\n  name: string;\n  title: string;\n  entities: AXPEntity[];\n}\n\nexport interface AXPModule {\n  name: string;\n  title: string;\n  aggregates: AXPAggregate[];\n  relationships?: AXPRelationship[];\n}\n\nexport interface AXPApplication {\n  name: string;\n  title: string;\n  modules: AXPModule[];\n}\n\nexport interface AXPEntityMasterLayoutView {\n  title?: string;\n  sections: AXPEntitySectionView[];\n  properties?: AXPEntityPropertyView[];\n}\nexport interface AXPEntityMasterCreateLayoutView extends AXPEntityMasterLayoutView {\n  steps?: {\n    id: string;\n    title: string;\n    description?: string;\n  };\n}\n\nexport interface AXPEntityMasterUpdateLayoutView extends AXPEntityMasterLayoutView {}\n\nexport interface AXPEntityMasterSingleLayoutView extends AXPEntityMasterLayoutView {\n  title: string;\n  description?: string;\n  actions?: AXPEntityAction[];\n}\n\nexport interface AXPEntityMasterListView {\n  title?: string;\n  description?: string;\n  actions?: AXPEntityAction[];\n  views: AXPQueryView[];\n}\n\nexport interface AXPEntityDetailListView {\n  title?: string;\n  description?: string;\n  columns: AXPEntityTableColumn[];\n  actions?: AXPEntityAction[];\n}\n\nexport interface AXPQueryView {\n  name: string;\n  fixed: boolean;\n  title: string;\n  columns: string[];\n  conditions: AXPQueryFilter[];\n  sorts: AXPQuerySort[];\n}\n\nexport interface AXPQueryFilter {\n  name: string; // entity property name\n  operator: AXDataSourceOperator;\n  value: any;\n}\n\nexport interface AXPQuerySort {\n  name: string; // entity property name\n  dir: 'asc' | 'desc';\n}\n\nexport function resolveActionLook(tr: AXPEntityAction): { icon: string; color: AXStyleColorType } {\n  switch (tr.type) {\n    case 'create':\n      return { color: 'primary', icon: 'fa-solid fa-add' };\n    case 'view':\n      return { color: 'primary', icon: 'fa-solid fa-eye' };\n    case 'info':\n      return { color: 'primary', icon: 'fa-solid fa-info' };\n    case 'delete':\n      return { color: 'danger', icon: 'fa-solid fa-trash' };\n    case 'print':\n      return { color: 'secondary', icon: 'fa-solid fa-print' };\n    case 'confirm':\n      return { color: 'success', icon: 'fa-solid fa-check' };\n    default:\n      return { color: 'primary', icon: '' };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.types.js","sourceRoot":"","sources":["../../../../../../../libs/platform/common/src/lib/app/application.types.ts"],"names":[],"mappings":"AAgBA,MAAM,CAAN,IAAY,mBAIX;AAJD,WAAY,mBAAmB;IAC7B,2EAAW,CAAA;IACX,2EAAW,CAAA;IACX,2EAAW,CAAA;AACb,CAAC,EAJW,mBAAmB,KAAnB,mBAAmB,QAI9B;AAED,MAAM,CAAN,IAAY,0BAIX;AAJD,WAAY,0BAA0B;IACpC,mFAAQ,CAAA;IACR,qFAAS,CAAA;IACT,uFAAU,CAAA;AACZ,CAAC,EAJW,0BAA0B,KAA1B,0BAA0B,QAIrC;AAUD,MAAM,CAAN,IAAY,qBAKX;AALD,WAAY,qBAAqB;IAC/B,gDAAuB,CAAA;IACvB,8CAAqB,CAAA;IACrB,kDAAyB,CAAA;IACzB,4CAAmB,CAAA;AACrB,CAAC,EALW,qBAAqB,KAArB,qBAAqB,QAKhC;AAED,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;IACjB,mCAAa,CAAA;AACf,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B;AAmOD,MAAM,UAAU,iBAAiB,CAAC,EAAmB;IACnD,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;QAChB,KAAK,QAAQ;YACX,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QACvD,KAAK,MAAM;YACT,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;QACvD,KAAK,MAAM;YACT,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;QACxD,KAAK,QAAQ;YACX,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;QACxD,KAAK,OAAO;YACV,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;QAC3D,KAAK,SAAS;YACZ,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;QACzD;YACE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAC1C,CAAC;AACH,CAAC","sourcesContent":["import { AXDataSourceOperator, AXStyleColorType } from '@acorex/components/common';\nimport { AXPOptionsData, AXPValidationRules } from '@acorex/platform/core';\nimport { AXPWidgetTypesMap } from '@acorex/platform/layout/builder';\nimport { AXPGridLayoutOptions } from '../layout';\n\nexport interface AXEntityPropertyWidget {\n  type: AXPWidgetTypesMap[keyof AXPWidgetTypesMap];\n  path: string;\n  id?: string;\n  formula?: string;\n  children?: AXEntityPropertyWidget[];\n  mode: 'view' | 'edit' | 'designer';\n  options?: Record<string, any>;\n  triggers?: { event: string; action: string; disabled?: boolean }[];\n}\n\nexport enum AXPRelationshipKind {\n  Association,\n  Composition,\n  Aggregation,\n}\n\nexport enum AXPRelationshipCardinality {\n  OneToOne,\n  OneToMany,\n  ManyToMany,\n}\n\nexport interface AXPRelationship {\n  id: string;\n  from: string;\n  to: string;\n  kind: AXPRelationshipKind;\n  cardinality: AXPRelationshipCardinality;\n}\n\nexport enum AXPEntityCommandScope {\n  TypeLevel = 'typeLevel',\n  Selected = 'selected',\n  Individual = 'individual',\n  Section = 'section',\n}\n\nexport enum AXPEntityQueryType {\n  Single = 'single',\n  List = 'list',\n}\n\nexport interface AXPEntityPropertyLayoutConfig extends AXPGridLayoutOptions {\n  order?: number;\n}\n\nexport interface AXPEntityPropertyGroup {\n  id: string;\n  title: string;\n  description?: string;\n  permissions?: string[];\n}\n\nexport interface AXPEntityPropertyView {\n  name: string;\n  permissions?: string[];\n  layout?: AXPEntityPropertyLayoutConfig;\n}\n\nexport interface AXPEntityPropertyUpdateView extends AXPEntityPropertyView { }\n\nexport interface AXPEntityPropertyCreateView extends AXPEntityPropertyView {\n  defaultValue?: any;\n}\n\nexport interface AXPEntitySectionView {\n  id: string;\n  description?: string;\n  order?: number;\n  layout?: AXPEntityPropertyLayoutConfig;\n}\n\nexport interface AXPEntityProperty {\n  name: string;\n  title?: string;\n  description?: string;\n  groupId?: string;\n  reference?: {\n    relationId: string;\n  };\n  schema: {\n    dataType: string;\n    nullable?: boolean;\n    readonly?: boolean;\n    hidden?: boolean;\n    defaultValue?: any | string | ((context: any | null) => any);\n    unique?: {\n      enabled: boolean;\n    };\n    interface?: Partial<AXEntityPropertyWidget>;\n  };\n  options?: {\n    filter?: {\n      advance?: {\n        enabled?: boolean;\n        widget?: AXPOptionsData;\n      };\n      inline?: {\n        enabled?: boolean;\n      };\n    };\n    sort?: {\n      enabled?: boolean;\n    };\n  };\n  validations?: AXPValidationRules;\n}\n\nexport interface AXPEntityTableColumn {\n  name: string;\n  title?: string;\n  options?: {\n    visible?: boolean;\n    width?: string;\n    [name: string]: any;\n  };\n}\n\nexport interface AXPEntityCommand {\n  execute: string | Function; // As runnable expression\n  permissions?: string[];\n}\n\nexport interface AXPEntityQuery {\n  execute: string | Function; // As runnable expression\n  type: AXPEntityQueryType;\n}\n\nexport interface AXPEntityHistory { }\n\nexport interface AXPEntityAction {\n  permissions?: string[];\n  command: string;\n  title: string;\n  type: 'create' | 'update' | 'delete' | 'print' | 'confirm' | 'report' | 'info' | 'view';\n  priority: 'primary' | 'secondary';\n  color?: 'primary' | 'danger' | 'success' | 'warning';\n  separated?: boolean;\n  icon?: string;\n  scope: AXPEntityCommandScope;\n}\n\nexport interface AXPEntity {\n  module: string;\n  name: string;\n  source: string;\n  title: string;\n  formats: {\n    individual: string;\n    plural: string;\n    lookup?: string;\n  };\n  relatedEntities?: AXPRelatedEntity[];\n  groups?: AXPEntityPropertyGroup[];\n  properties: AXPEntityProperty[];\n  columns?: AXPEntityTableColumn[];\n  commands?: {\n    create: AXPEntityCommand | undefined;\n    update?: AXPEntityCommand | undefined;\n    delete?: AXPEntityCommand | undefined;\n    [name: string]: AXPEntityCommand | undefined;\n  };\n  queries: {\n    byKey: AXPEntityQuery;\n    list?: AXPEntityQuery;\n    lookup?: AXPEntityQuery;\n    history?: AXPEntityQuery;\n    comments?: AXPEntityQuery;\n    [name: string]: AXPEntityQuery | undefined;\n  };\n  validations?: AXPValidationRules;\n  interfaces?: {\n    master?: {\n      single?: AXPEntityMasterSingleLayoutView;\n      list?: AXPEntityMasterListView;\n      create?: AXPEntityMasterCreateLayoutView;\n      update?: AXPEntityMasterUpdateLayoutView;\n    };\n    detail?: {\n      list?: AXPEntityDetailListView;\n    };\n  };\n}\n\nexport interface AXPRelatedEntity {\n  entity: string;\n  title?: string;\n  columns?: string[];\n  conditions?: AXPQueryFilter[];\n  sorts?: AXPQuerySort[];\n}\n\nexport interface AXPAggregate {\n  id: string;\n  name: string;\n  title: string;\n  entities: AXPEntity[];\n}\n\nexport interface AXPModule {\n  name: string;\n  title: string;\n  aggregates: AXPAggregate[];\n  relationships?: AXPRelationship[];\n}\n\nexport interface AXPApplication {\n  name: string;\n  title: string;\n  modules: AXPModule[];\n}\n\nexport interface AXPEntityMasterLayoutView {\n  title?: string;\n  sections: AXPEntitySectionView[];\n  properties?: AXPEntityPropertyView[];\n}\nexport interface AXPEntityMasterCreateLayoutView extends AXPEntityMasterLayoutView {\n  steps?: {\n    id: string;\n    title: string;\n    description?: string;\n  };\n}\n\nexport interface AXPEntityMasterUpdateLayoutView extends AXPEntityMasterLayoutView { }\n\nexport interface AXPEntityMasterSingleLayoutView extends AXPEntityMasterLayoutView {\n  title: string;\n  description?: string;\n  actions?: AXPEntityAction[];\n}\n\nexport interface AXPEntityMasterListView {\n  title?: string;\n  description?: string;\n  actions?: AXPEntityAction[];\n  views: AXPQueryView[];\n}\n\nexport interface AXPEntityDetailListView {\n  title?: string;\n  description?: string;\n  columns: AXPEntityTableColumn[];\n  actions?: AXPEntityAction[];\n}\n\nexport interface AXPQueryView {\n  name: string;\n  fixed: boolean;\n  title: string;\n  columns: string[];\n  conditions: AXPQueryFilter[];\n  sorts: AXPQuerySort[];\n}\n\nexport interface AXPQueryFilter {\n  name: string; // entity property name\n  operator: AXDataSourceOperator;\n  value: any;\n}\n\nexport interface AXPQuerySort {\n  name: string; // entity property name\n  dir: 'asc' | 'desc';\n}\n\nexport function resolveActionLook(tr: AXPEntityAction): { icon: string; color: AXStyleColorType } {\n  switch (tr.type) {\n    case 'create':\n      return { color: 'primary', icon: 'fa-solid fa-add' };\n    case 'view':\n      return { color: 'primary', icon: 'fa-solid fa-eye' };\n    case 'info':\n      return { color: 'primary', icon: 'fa-solid fa-info' };\n    case 'delete':\n      return { color: 'danger', icon: 'fa-solid fa-trash' };\n    case 'print':\n      return { color: 'secondary', icon: 'fa-solid fa-print' };\n    case 'confirm':\n      return { color: 'success', icon: 'fa-solid fa-check' };\n    default:\n      return { color: 'primary', icon: '' };\n  }\n}\n"]}

package/esm2022/common/lib/common.module.mjs

@@ -1,23 +1,25 @@
 import { AXPopupModule } from '@acorex/components/popup';
+import { AXToastModule } from '@acorex/components/toast';
 import { AXDateTimeModule } from '@acorex/core/date-time';
+import { AXPWorkflowModule } from '@acorex/platform/workflow';
 import { ErrorHandler, Inject, NgModule } from '@angular/core';
 import { RouterModule } from '@angular/router';
 import { EffectsModule } from '@ngrx/effects';
+import { StoreModule } from '@ngrx/store';
+import { AXPAppStartUpProvider, AXPAppStartUpService } from './app/app-startup.service';
+import { AXPDataSeederService } from './data';
 import { AXPErrorHandlerRegistryService, AXPGlobalErrorHandler } from './errors';
-import { AXPCommonEffects, AXPLoadSettingAction } from './store';
-import { Store, StoreModule } from '@ngrx/store';
 import { AXPLayoutEffects, AXPLayoutFeature } from './layout';
-import { AXToastModule } from '@acorex/components/toast';
-import { AXPWorkflowModule } from '@acorex/platform/workflow';
-import { AXPDialogConfirmAction, AXPToastAction } from './workflows';
-import { AXPAppStartUpProvider, AXPAppStartUpService } from './app/app-startup.service';
 import { AXPSettingsService } from './settings';
+import { AXPCommonEffects } from './store';
+import { AXPDialogConfirmAction, AXPToastAction } from './workflows';
 import * as i0 from "@angular/core";
 import * as i1 from "./app/app-startup.service";
-import * as i2 from "@ngrx/store";
-import * as i3 from "./settings";
+import * as i2 from "./settings";
+import * as i3 from "./data";
 import * as i4 from "@ngrx/effects";
-import * as i5 from "@acorex/platform/workflow";
+import * as i5 from "@ngrx/store";
+import * as i6 from "@acorex/platform/workflow";
 export class AXPCommonModule {
     static forRoot(configs) {
         return {
@@ -54,37 +56,42 @@ export class AXPCommonModule {
     /**
      * @ignore
      */
-    constructor(instances, appInitService, store, settingsService) {
-        this.appInitService = appInitService;
-        this.store = store;
-        this.settingsService = settingsService;
+    constructor(instances, appInitService, settingsService, seederService) {
         instances.forEach((f) => {
             f();
         });
-        this.appInitService.registerTask({
+        appInitService.registerTask({
             name: 'Modules',
-            statusText: "Initializing Modules ...",
+            statusText: 'Initializing Modules ...',
             run: () => new Promise((resolve) => {
                 setTimeout(() => {
                     resolve();
                 }, 250);
-            })
+            }),
         });
         //
-        this.appInitService.registerTask({
+        appInitService.registerTask({
             name: 'Settings',
-            statusText: "Loading Settings ...",
+            statusText: 'Loading Settings ...',
             run: () => new Promise((resolve) => {
                 setTimeout(async () => {
                     await settingsService.load();
-                    store.dispatch(AXPLoadSettingAction());
                     resolve();
                 }, 250);
-            })
+            }),
+        });
+        //
+        //
+        appInitService.registerTask({
+            name: 'Seeder',
+            statusText: 'Seed Data ...',
+            run: async () => {
+                await seederService.seed();
+            },
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: i1.AXPAppStartUpService }, { token: i2.Store }, { token: i3.AXPSettingsService }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, imports: [i4.EffectsFeatureModule, i2.StoreFeatureModule, i5.AXPWorkflowModule, AXPopupModule,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, deps: [{ token: 'AXPCommonModuleFactory' }, { token: i1.AXPAppStartUpService }, { token: i2.AXPSettingsService }, { token: i3.AXPDataSeederService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, imports: [i4.EffectsFeatureModule, i5.StoreFeatureModule, i6.AXPWorkflowModule, AXPopupModule,
             AXDateTimeModule,
             AXToastModule], exports: [RouterModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommonModule, providers: [
@@ -97,9 +104,9 @@ export class AXPCommonModule {
             StoreModule.forFeature(AXPLayoutFeature),
             AXPWorkflowModule.forChild({
                 actions: {
-                    "navigate": AXPDialogConfirmAction,
-                    "show-prompt-dialog": AXPDialogConfirmAction,
-                    "show-toast": AXPToastAction,
+                    navigate: AXPDialogConfirmAction,
+                    'show-prompt-dialog': AXPDialogConfirmAction,
+                    'show-toast': AXPToastAction,
                 },
             }),
             AXPopupModule,
@@ -114,14 +121,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                         StoreModule.forFeature(AXPLayoutFeature),
                         AXPWorkflowModule.forChild({
                             actions: {
-                                "navigate": AXPDialogConfirmAction,
-                                "show-prompt-dialog": AXPDialogConfirmAction,
-                                "show-toast": AXPToastAction,
+                                navigate: AXPDialogConfirmAction,
+                                'show-prompt-dialog': AXPDialogConfirmAction,
+                                'show-toast': AXPToastAction,
                             },
                         }),
                         AXPopupModule,
                         AXDateTimeModule,
-                        AXToastModule
+                        AXToastModule,
                     ],
                     exports: [RouterModule],
                     providers: [
@@ -135,5 +142,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: ['AXPCommonModuleFactory']
-                }] }, { type: i1.AXPAppStartUpService }, { type: i2.Store }, { type: i3.AXPSettingsService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.module.js","sourceRoot":"","sources":["../../../../../../libs/platform/common/src/lib/common.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXPopupModule } from '@acorex/components/popup';\nimport { AXDateTimeModule } from '@acorex/core/date-time';\nimport { ErrorHandler, Inject, ModuleWithProviders, NgModule } from '@angular/core';\nimport { RouterModule } from '@angular/router';\nimport { EffectsModule } from '@ngrx/effects';\nimport { AXPErrorHandler, AXPErrorHandlerRegistryService, AXPGlobalErrorHandler } from './errors';\nimport { AXPCommonEffects, AXPLoadSettingAction } from './store';\nimport { Store, StoreModule } from '@ngrx/store';\nimport { AXPLayoutEffects, AXPLayoutFeature } from './layout';\nimport { AXToastModule } from '@acorex/components/toast';\nimport { AXPWorkflowModule } from '@acorex/platform/workflow';\nimport { AXPDialogConfirmAction, AXPToastAction } from './workflows';\nimport { AXPAppStartUpProvider, AXPAppStartUpService } from './app/app-startup.service';\nimport { AXPSettingsService } from './settings';\n\nexport interface AXPCommonModuleConfigs {\n  errorHandlers: (new () => AXPErrorHandler)[];\n}\n\n@NgModule({\n  imports: [\n    EffectsModule.forFeature([AXPCommonEffects, AXPLayoutEffects]),\n    StoreModule.forFeature(AXPLayoutFeature),\n    AXPWorkflowModule.forChild({\n      actions: {\n        \"navigate\": AXPDialogConfirmAction,\n        \"show-prompt-dialog\": AXPDialogConfirmAction,\n        \"show-toast\": AXPToastAction,\n      },\n    }),\n    AXPopupModule,\n    AXDateTimeModule,\n    AXToastModule\n  ],\n  exports: [RouterModule],\n  providers: [\n    AXPAppStartUpProvider,\n    {\n      provide: ErrorHandler,\n      useClass: AXPGlobalErrorHandler,\n    },\n  ],\n})\nexport class AXPCommonModule {\n  static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule> {\n    return {\n      ngModule: AXPCommonModule,\n      providers: [\n        ...(configs?.errorHandlers || []),\n        {\n          provide: 'AXPCommonModuleFactory',\n          useFactory: (registry: AXPErrorHandlerRegistryService) => () => {\n            registry.register(...(configs?.errorHandlers || []));\n          },\n          deps: [AXPErrorHandlerRegistryService],\n          multi: true,\n        },\n      ],\n    };\n  }\n\n  static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule> {\n    return {\n      ngModule: AXPCommonModule,\n      providers: [\n        ...(configs?.errorHandlers || []),\n        {\n          provide: 'AXPCommonModuleFactory',\n          useFactory: (registry: AXPErrorHandlerRegistryService) => () => {\n            registry.register(...(configs?.errorHandlers || []));\n          },\n          deps: [AXPErrorHandlerRegistryService],\n          multi: true,\n        },\n      ],\n    };\n  }\n\n  /**\n   * @ignore\n   */\n  constructor(\n    @Inject('AXPCommonModuleFactory') instances: any[],\n    private appInitService: AXPAppStartUpService,\n    private store: Store,\n    private settingsService: AXPSettingsService\n  ) {\n    instances.forEach((f) => {\n      f();\n    });\n\n    this.appInitService.registerTask({\n      name: 'Modules',\n      statusText: \"Initializing Modules ...\",\n      run: () => new Promise<void>((resolve) => {\n        setTimeout(() => {\n          resolve();\n        }, 250);\n      })\n    });\n    //\n    this.appInitService.registerTask({\n      name: 'Settings',\n      statusText: \"Loading Settings ...\",\n      run: () => new Promise<void>((resolve) => {\n        setTimeout(async () => {\n          await settingsService.load();\n          store.dispatch(AXPLoadSettingAction())\n          resolve()\n        }, 250);\n      })\n    });\n  }\n}\n"]}
+                }] }, { type: i1.AXPAppStartUpService }, { type: i2.AXPSettingsService }, { type: i3.AXPDataSeederService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.module.js","sourceRoot":"","sources":["../../../../../../libs/platform/common/src/lib/common.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXPopupModule } from '@acorex/components/popup';\nimport { AXToastModule } from '@acorex/components/toast';\nimport { AXDateTimeModule } from '@acorex/core/date-time';\nimport { AXPWorkflowModule } from '@acorex/platform/workflow';\nimport { ErrorHandler, Inject, ModuleWithProviders, NgModule } from '@angular/core';\nimport { RouterModule } from '@angular/router';\nimport { EffectsModule } from '@ngrx/effects';\nimport { StoreModule } from '@ngrx/store';\nimport { AXPAppStartUpProvider, AXPAppStartUpService } from './app/app-startup.service';\nimport { AXPDataSeederService } from './data';\nimport { AXPErrorHandler, AXPErrorHandlerRegistryService, AXPGlobalErrorHandler } from './errors';\nimport { AXPLayoutEffects, AXPLayoutFeature } from './layout';\nimport { AXPSettingsService } from './settings';\nimport { AXPCommonEffects } from './store';\nimport { AXPDialogConfirmAction, AXPToastAction } from './workflows';\n\nexport interface AXPCommonModuleConfigs {\n  errorHandlers: (new () => AXPErrorHandler)[];\n}\n\n@NgModule({\n  imports: [\n    EffectsModule.forFeature([AXPCommonEffects, AXPLayoutEffects]),\n    StoreModule.forFeature(AXPLayoutFeature),\n    AXPWorkflowModule.forChild({\n      actions: {\n        navigate: AXPDialogConfirmAction,\n        'show-prompt-dialog': AXPDialogConfirmAction,\n        'show-toast': AXPToastAction,\n      },\n    }),\n    AXPopupModule,\n    AXDateTimeModule,\n    AXToastModule,\n  ],\n  exports: [RouterModule],\n  providers: [\n    AXPAppStartUpProvider,\n    {\n      provide: ErrorHandler,\n      useClass: AXPGlobalErrorHandler,\n    },\n  ],\n})\nexport class AXPCommonModule {\n  static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule> {\n    return {\n      ngModule: AXPCommonModule,\n      providers: [\n        ...(configs?.errorHandlers || []),\n        {\n          provide: 'AXPCommonModuleFactory',\n          useFactory: (registry: AXPErrorHandlerRegistryService) => () => {\n            registry.register(...(configs?.errorHandlers || []));\n          },\n          deps: [AXPErrorHandlerRegistryService],\n          multi: true,\n        },\n      ],\n    };\n  }\n\n  static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule> {\n    return {\n      ngModule: AXPCommonModule,\n      providers: [\n        ...(configs?.errorHandlers || []),\n        {\n          provide: 'AXPCommonModuleFactory',\n          useFactory: (registry: AXPErrorHandlerRegistryService) => () => {\n            registry.register(...(configs?.errorHandlers || []));\n          },\n          deps: [AXPErrorHandlerRegistryService],\n          multi: true,\n        },\n      ],\n    };\n  }\n\n  /**\n   * @ignore\n   */\n  constructor(\n    @Inject('AXPCommonModuleFactory') instances: any[],\n    appInitService: AXPAppStartUpService,\n    settingsService: AXPSettingsService,\n    seederService: AXPDataSeederService\n  ) {\n    instances.forEach((f) => {\n      f();\n    });\n\n    appInitService.registerTask({\n      name: 'Modules',\n      statusText: 'Initializing Modules ...',\n      run: () =>\n        new Promise<void>((resolve) => {\n          setTimeout(() => {\n            resolve();\n          }, 250);\n        }),\n    });\n    //\n    appInitService.registerTask({\n      name: 'Settings',\n      statusText: 'Loading Settings ...',\n      run: () =>\n        new Promise<void>((resolve) => {\n          setTimeout(async () => {\n            await settingsService.load();\n            resolve();\n          }, 250);\n        }),\n    });\n    //\n    //\n    appInitService.registerTask({\n      name: 'Seeder',\n      statusText: 'Seed Data ...',\n      run: async () => {\n        await seederService.seed();\n      },\n    });\n  }\n}\n"]}