@acorex/connectivity 18.2.0 → 18.2.1

package/fesm2022/acorex-connectivity-mock.mjs

@@ -1,13 +1,15 @@
-import { AXMCommentService } from '@acorex/modules/conversation';
+import { AXPCommentServiceImpl, AXMCommentService } from '@acorex/modules/conversation';
 import { AXMNotificationService } from '@acorex/modules/notification-management';
 import { AXPDataGenerator, AXPDexieEntityStorageService, AXPEntityStorageService, AXP_DATA_SEEDER_TOKEN } from '@acorex/platform/common';
-import { AXPDesignerConnectorAbstract } from '@acorex/platform/layout/designer';
 import * as i0 from '@angular/core';
 import { inject, Injectable, NgModule } from '@angular/core';
 import { APPLICATION_SOURCE_NAME, MODULE_SOURCE_NAME, ENTITY_SOURCE_NAME, FEATURE_SOURCE_NAME, PERMISSION_SOURCE_NAME, PROPERTY_SOURCE_NAME } from '@acorex/modules/application-management';
-import { AXPCommentServiceImpl } from '@acorex/modules/platform-management';
 import { AXPSessionService } from '@acorex/platform/auth';
+import { AXP_WIDGET_DATASOURCE_PROVIDER } from '@acorex/platform/layout/builder';
+import { AXPDesignerConnectorAbstract } from '@acorex/platform/layout/designer';
 import { convertArrayToDataSource } from '@acorex/components/common';
+import { LANGUAGE_SOURCE_NAME, CULTURE_SOURCE_NAME, TIMEZONE_SOURCE_NAME } from '@acorex/modules/localization-management';
+import { CURRENCY_SOURCE_NAME, COUNTRY_SOURCE_NAME } from '@acorex/modules/platform-management';
 import { CATEGORY_SOURCE_NAME, TEMPLATE_SOURCE_NAME } from '@acorex/modules/template-management';
 
 const APPLICATIONS = Array.from({ length: 5 }).map((_, i) => {
@@ -298,59 +300,339 @@ class AXMCommentMockService extends AXPCommentServiceImpl {
     }
 }
 
-class AXPMockDesignerConnector extends AXPDesignerConnectorAbstract {
-    //#region DataSources Management
-    async getDataSourcesNames() {
+class AXPMockWidgetDataSourceProvider {
+    async items() {
         return [
             {
-                id: "countries",
-                title: "Countries"
+                name: 'mock.users',
+                title: 'Users',
+                columns: [],
+                samples: [
+                    {
+                        id: '2',
+                        title: 'Alex Jakson',
+                    },
+                    {
+                        id: '3',
+                        title: 'Emma Smith',
+                    },
+                ],
+                source: () => convertArrayToDataSource([
+                    {
+                        id: '1',
+                        title: 'Arash Oshnoudi',
+                    },
+                    {
+                        id: '2',
+                        title: 'Alex Smith',
+                    },
+                    {
+                        id: '3',
+                        title: 'Emma Jakson',
+                    },
+                ]),
             },
-            {
-                id: "users",
-                title: "Users"
-            }
         ];
     }
-    async getDataSource(name) {
-        switch (name) {
-            case 'countries':
-                return {
-                    columns: [
-                        {
-                            name: 'id',
-                            title: 'Id',
-                        },
-                        {
-                            name: 'title',
-                            title: 'Title',
-                        }
-                    ],
-                    name: "countries",
-                    source: convertArrayToDataSource([
+}
+
+class AXPMockDesignerConnector extends AXPDesignerConnectorAbstract {
+    //#region Save and load Widgets
+    save() {
+        throw new Error('Method not implemented.');
+    }
+    load(id) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+class AXCFormManagementMockModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXCFormManagementMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXCFormManagementMockModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXCFormManagementMockModule, providers: [
+            {
+                provide: AXPDesignerConnectorAbstract,
+                useClass: AXPMockDesignerConnector,
+            },
+            {
+                provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                useClass: AXPMockWidgetDataSourceProvider,
+                multi: true,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXCFormManagementMockModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
                         {
-                            id: "1",
-                            title: "Iran"
+                            provide: AXPDesignerConnectorAbstract,
+                            useClass: AXPMockDesignerConnector,
                         },
                         {
-                            id: "2",
-                            title: "Usa"
+                            provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                            useClass: AXPMockWidgetDataSourceProvider,
+                            multi: true,
                         },
-                    ])
-                };
-            default:
-                return undefined;
-        }
+                    ],
+                }]
+        }] });
+
+const LANGUAGES = [
+    {
+        id: AXPDataGenerator.uuid(),
+        title: 'English',
+        code: 'en'
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        title: 'Persian',
+        code: 'fa'
     }
-    //#endregion
-    //#region Save and load Widgets
-    save() {
-        throw new Error("Method not implemented.");
+];
+
+class AXPLanguageDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
     }
-    load(id) {
-        throw new Error("Method not implemented.");
+    async seed() {
+        await this.storageService.initial(LANGUAGE_SOURCE_NAME, LANGUAGES);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLanguageDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLanguageDataSeeder }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLanguageDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+const names = ['key', 'counter', 'logo', 'tenant'];
+const data = [
+    ['key1', 'string'],
+    ['sequence', 'integer'],
+    ['appLogo', 'function'],
+    ['CompanyName', 'function'],
+];
+const GLOBAL_VARIABLES = Array.from({ length: 4 }).map((element, i) => {
+    return {
+        id: AXPDataGenerator.uuid(),
+        name: names[i],
+        title: names[i],
+        dataType: data[i][1],
+        dataValue: data[i][0],
+    };
+});
+
+class AXPGlobalVariablesDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial('globalVariable', GLOBAL_VARIABLES);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPGlobalVariablesDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPGlobalVariablesDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPGlobalVariablesDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+const Currencies = [
+    {
+        id: AXPDataGenerator.uuid(),
+        code: 'AFN',
+        title: 'Afghan afghani',
+        symbol: '؋',
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        code: 'EUR',
+        title: 'Euro',
+        symbol: '€',
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        code: 'JPY',
+        title: 'Japanese Yen',
+        symbol: '¥',
+    },
+];
+
+class AXPCurrencyDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(CURRENCY_SOURCE_NAME, Currencies);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCurrencyDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCurrencyDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCurrencyDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+const COUNTRIES = [
+    {
+        id: AXPDataGenerator.uuid(),
+        title: 'Afghanistan',
+        iso2: 'AF',
+        iso3: 'AFG',
+        numericCode: '004',
+        phoneCode: '93',
+        capital: 'Kabul',
+        tld: '.af',
+        nativeName: 'افغانستان',
+        region: 'Asia',
+        subregion: 'Southern Asia',
+        nationality: 'Afghan',
+        geo: {
+            latitude: '33.00000000',
+            longitude: '65.00000000',
+        },
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        title: 'United States',
+        iso2: 'US',
+        iso3: 'USA',
+        numericCode: '840',
+        phoneCode: '1',
+        capital: 'Washington, D.C.',
+        tld: '.us',
+        nativeName: 'United States',
+        region: 'Americas',
+        subregion: 'Northern America',
+        nationality: 'American',
+        geo: {
+            latitude: '37.0902',
+            longitude: '-95.7129',
+        },
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        title: 'France',
+        iso2: 'FR',
+        iso3: 'FRA',
+        numericCode: '250',
+        phoneCode: '33',
+        capital: 'Paris',
+        tld: '.fr',
+        nativeName: 'France',
+        region: 'Europe',
+        subregion: 'Western Europe',
+        nationality: 'French',
+        geo: {
+            latitude: '46.6034',
+            longitude: '1.8883',
+        },
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        title: 'Japan',
+        iso2: 'JP',
+        iso3: 'JPN',
+        numericCode: '392',
+        phoneCode: '81',
+        capital: 'Tokyo',
+        tld: '.jp',
+        nativeName: '日本',
+        region: 'Asia',
+        subregion: 'Eastern Asia',
+        nationality: 'Japanese',
+        geo: {
+            latitude: '36.2048',
+            longitude: '138.2529',
+        },
+    },
+];
+
+class AXPCountryDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(COUNTRY_SOURCE_NAME, COUNTRIES);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCountryDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCountryDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCountryDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+const CULTURES = [
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'English (United States)',
+        title: 'English (United States)',
+        language: LANGUAGES[0],
+        country: COUNTRIES[0], // Assuming 'unitedStates' is defined as in previous examples
+        locale: 'en-US', //TODO need define in backend Getter just
+        dateFormat: 'MM/DD/YYYY',
+        timeFormat: 'hh:mm:ss A',
+    },
+];
+
+class AXPCultureDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(CULTURE_SOURCE_NAME, CULTURES);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCultureDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCultureDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCultureDataSeeder, decorators: [{
+            type: Injectable
+        }] });
+
+const TIME_ZONES = [
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'Asia/Kabul',
+        title: 'Asia/Kabul',
+        gmtOffset: 16200,
+        gmtOffsetName: 'UTC+04:30',
+        abbreviation: 'AFT',
+        tzName: 'Afghanistan Time',
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'America/New_York',
+        title: 'America/New_York',
+        gmtOffset: -18000, // -5 hours in seconds
+        gmtOffsetName: 'UTC-05:00',
+        abbreviation: 'EST',
+        tzName: 'Eastern Standard Time',
+    },
+    {
+        id: AXPDataGenerator.uuid(),
+        name: 'Europe/Amsterdam',
+        title: 'Europe/Amsterdam',
+        gmtOffset: 3600, // 1 hour in seconds
+        gmtOffsetName: 'UTC+01:00',
+        abbreviation: 'CET',
+        tzName: 'Central European Time',
+    },
+];
+
+class AXPTimeZoneDataSeeder {
+    constructor() {
+        this.storageService = inject(AXPDexieEntityStorageService);
+    }
+    async seed() {
+        await this.storageService.initial(TIMEZONE_SOURCE_NAME, TIME_ZONES);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPTimeZoneDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPTimeZoneDataSeeder }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPTimeZoneDataSeeder, decorators: [{
+            type: Injectable
+        }] });
 
 class AXMMockNotificationService {
     constructor() {
@@ -424,64 +706,6 @@ function generateNotification() {
     };
 }
 
-const names = ['key', 'counter', 'logo', 'tenant'];
-const data = [
-    ['key1', 'string'],
-    ['sequence', 'integer'],
-    ['appLogo', 'function'],
-    ['CompanyName', 'function'],
-];
-const GLOBAL_VARIABLES = Array.from({ length: 4 }).map((element, i) => {
-    return {
-        id: AXPDataGenerator.uuid(),
-        name: names[i],
-        title: names[i],
-        dataType: data[i][1],
-        dataValue: data[i][0],
-    };
-});
-
-class AXPGlobalVariablesDataSeeder {
-    constructor() {
-        this.storageService = inject(AXPDexieEntityStorageService);
-    }
-    async seed() {
-        await this.storageService.initial('globalVariable', GLOBAL_VARIABLES);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPGlobalVariablesDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPGlobalVariablesDataSeeder }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPGlobalVariablesDataSeeder, decorators: [{
-            type: Injectable
-        }] });
-
-const LANGUAGES = [
-    {
-        id: AXPDataGenerator.uuid(),
-        title: 'English',
-        code: 'en'
-    },
-    {
-        id: AXPDataGenerator.uuid(),
-        title: 'Persian',
-        code: 'fa'
-    }
-];
-
-class AXPLanguageDataSeeder {
-    constructor() {
-        this.storageService = inject(AXPDexieEntityStorageService);
-    }
-    async seed() {
-        await this.storageService.initial('language', LANGUAGES);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLanguageDataSeeder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLanguageDataSeeder }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPLanguageDataSeeder, decorators: [{
-            type: Injectable
-        }] });
-
 const TEXT_TEMPLATE_CATEGORY = [
     {
         id: AXPDataGenerator.uuid(),
@@ -629,17 +853,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
 
 class AXCMockModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXCMockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXCMockModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXCMockModule, imports: [AXCFormManagementMockModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXCMockModule, providers: [
             AXPDexieEntityStorageService,
             {
                 provide: AXMNotificationService,
                 useClass: AXMMockNotificationService,
             },
-            {
-                provide: AXPDesignerConnectorAbstract,
-                useClass: AXPMockDesignerConnector,
-            },
             {
                 provide: AXPEntityStorageService,
                 useClass: AXPDexieEntityStorageService,
@@ -669,16 +889,36 @@ class AXCMockModule {
                 useClass: AXPApplicationTemplateDataSeeder,
                 multi: true,
             },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPCurrencyDataSeeder,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPTimeZoneDataSeeder,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPCountryDataSeeder,
+                multi: true,
+            },
+            {
+                provide: AXP_DATA_SEEDER_TOKEN,
+                useClass: AXPCultureDataSeeder,
+                multi: true,
+            },
             {
                 provide: AXMCommentService,
                 useClass: AXMCommentMockService,
             },
-        ] }); }
+        ], imports: [AXCFormManagementMockModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXCMockModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [],
+                    imports: [AXCFormManagementMockModule],
                     exports: [],
                     declarations: [],
                     providers: [
@@ -687,10 +927,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                             provide: AXMNotificationService,
                             useClass: AXMMockNotificationService,
                         },
-                        {
-                            provide: AXPDesignerConnectorAbstract,
-                            useClass: AXPMockDesignerConnector,
-                        },
                         {
                             provide: AXPEntityStorageService,
                             useClass: AXPDexieEntityStorageService,
@@ -720,6 +956,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImpor
                             useClass: AXPApplicationTemplateDataSeeder,
                             multi: true,
                         },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPCurrencyDataSeeder,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPTimeZoneDataSeeder,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPCountryDataSeeder,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_DATA_SEEDER_TOKEN,
+                            useClass: AXPCultureDataSeeder,
+                            multi: true,
+                        },
                         {
                             provide: AXMCommentService,
                             useClass: AXMCommentMockService,