@acorex/modules 18.2.0 → 18.2.1

package/fesm2022/acorex-modules-localization-management.mjs

@@ -0,0 +1,1019 @@
+import * as i0 from '@angular/core';
+import { inject, Injector, Injectable, signal, Component, NgModule } from '@angular/core';
+import * as i1$1 from '@acorex/platform/common';
+import { AXMEntityCrudServiceImpl, AXPDataGenerator, AXPEntityQueryType, AXPEntityCommandScope, AXPSettingsService, AXP_MENU_PROVIDER, AXPComponentSlotModule } from '@acorex/platform/common';
+import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import { AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import * as i3 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i1 from '@acorex/components/dropdown';
+import { AXDropdownModule } from '@acorex/components/dropdown';
+import { AXPopoverModule } from '@acorex/components/popover';
+import { CommonModule } from '@angular/common';
+import { AXTranslationService } from '@acorex/core/translation';
+import { signalStore, withState, withMethods, patchState } from '@ngrx/signals';
+
+class AXMLocalizationManagementModuleEntityLoader {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    async get(moduleName, entityName) {
+        return new Promise(async (resolve) => {
+            switch (entityName) {
+                case 'language': {
+                    const entity = (await Promise.resolve().then(function () { return language_entity; })).languageEntityFactory;
+                    resolve(entity(this.injector));
+                    break;
+                }
+                case 'time-zone': {
+                    const entity = (await Promise.resolve().then(function () { return timeZone_entity; })).timeZoneEntityFactory;
+                    resolve(entity(this.injector));
+                    break;
+                }
+                case 'culture': {
+                    const entity = (await Promise.resolve().then(function () { return culture_entity; })).cultureEntityFactory;
+                    resolve(entity(this.injector));
+                    break;
+                }
+                default:
+                    resolve(null);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalizationManagementModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalizationManagementModuleEntityLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalizationManagementModuleEntityLoader, decorators: [{
+            type: Injectable
+        }] });
+
+const LANGUAGE_SOURCE_NAME = 'localization-management.language';
+const TIMEZONE_SOURCE_NAME = 'localization-management.timeZone';
+const CULTURE_SOURCE_NAME = 'localization-management.culture';
+
+class AXMLanguageService extends AXMEntityCrudServiceImpl {
+}
+class AXMLanguageServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(LANGUAGE_SOURCE_NAME);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function languageEntityFactory(injector) {
+    const dataService = injector.get(AXMLanguageService);
+    const entityDef = {
+        module: 'localization-management',
+        name: 'language',
+        source: 'localizationManagement.language',
+        title: 'Language',
+        formats: {
+            individual: 'Language',
+            plural: 'Languages',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'language',
+                title: 'Language',
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'language',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'code',
+                title: 'Code',
+                groupId: 'language',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'code' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
+                    dataService.insertOne(entity);
+                    return Promise.resolve(entity);
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    await await dataService.deleteOne(id);
+                    return Promise.resolve();
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            await dataService.updateOne(data.id, data);
+                            resolve(data);
+                        }, 1000);
+                    });
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'language',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'language',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'language',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: 'Create New',
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 'Delete Items',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 'Details',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 'Delete',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 'All Items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var language_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    languageEntityFactory: languageEntityFactory
+});
+
+const LANGUAGE_VARIANT_KEY = 'localization:language';
+// ThemeStore - Manages theme settings and system changes
+const AXPLocalizationStoreService = signalStore({ providedIn: 'root' }, 
+// Initial State
+withState((translationService = inject(AXTranslationService)) => {
+    const state = {
+        language: translationService.getDefaultLang(),
+    };
+    return state;
+}), 
+// Computed Signals
+// withComputed(({ }) => ({
+// })),
+// Methods for State Management
+withMethods((store, settingService = inject(AXPSettingsService), translationService = inject(AXTranslationService)) => {
+    return {
+        changeLanguage(lang) {
+            settingService.set(LANGUAGE_VARIANT_KEY, lang);
+            translationService.setActiveLang(lang);
+            patchState(store, { language: lang });
+        },
+        async loadSetting() {
+            const lang = (await settingService.get(LANGUAGE_VARIANT_KEY)) ?? translationService.getDefaultLang();
+            settingService.set(LANGUAGE_VARIANT_KEY, lang);
+            translationService.setActiveLang(lang);
+            patchState(store, { language: lang });
+        },
+    };
+}));
+
+class AXMLanguageSlotComponent {
+    constructor() {
+        this.languageService = inject(AXMLanguageService);
+        this.store = inject(AXPLocalizationStoreService);
+        this.items = signal([]);
+    }
+    async ngOnInit() {
+        const items = (await this.languageService.query()).items.map(c => ({ code: c.code, title: c.title }));
+        this.items.set(items);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.0", type: AXMLanguageSlotComponent, isStandalone: true, selector: "ng-component", ngImport: i0, template: "<ax-button look=\"blank\">\n  <ax-icon class=\"fa-regular fa-globe\"> </ax-icon>\n  <ax-dropdown-panel>\n    <ax-button-item-list>\n      @for(lang of items(); track lang){\n      <ax-button-item [text]=\"lang.title\" [selected]=\"store.language()===lang.code\"\n        (onClick)=\"store.changeLanguage(lang.code)\">\n        <ax-prefix>\n          <ax-icon icon=\"fa-solid fa-flag\"> </ax-icon>\n        </ax-prefix>\n      </ax-button-item>\n      }\n    </ax-button-item-list>\n  </ax-dropdown-panel>\n</ax-button>", dependencies: [{ kind: "ngmodule", type: AXDropdownModule }, { kind: "component", type: i1.AXDropdownPanelComponent, selector: "ax-dropdown-panel", inputs: ["isOpen", "fitParent", "dropdownWidth", "position", "_target", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i2.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-sub-title, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXPopoverModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i3.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "type", "responsiveOn", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "responsiveOnChange", "loadingTextChange"] }, { kind: "component", type: i3.AXButtonItemComponent, selector: "ax-button-item", inputs: ["color", "disabled", "text", "selected", "divided", "data", "name"], outputs: ["onClick", "onFocus", "onBlur", "disabledChange"] }, { kind: "component", type: i3.AXButtonItemListComponent, selector: "ax-button-item-list", inputs: ["items"], outputs: ["onItemClick"] }, { kind: "ngmodule", type: CommonModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageSlotComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [AXDropdownModule, AXDecoratorModule, AXPopoverModule, AXButtonModule, CommonModule], template: "<ax-button look=\"blank\">\n  <ax-icon class=\"fa-regular fa-globe\"> </ax-icon>\n  <ax-dropdown-panel>\n    <ax-button-item-list>\n      @for(lang of items(); track lang){\n      <ax-button-item [text]=\"lang.title\" [selected]=\"store.language()===lang.code\"\n        (onClick)=\"store.changeLanguage(lang.code)\">\n        <ax-prefix>\n          <ax-icon icon=\"fa-solid fa-flag\"> </ax-icon>\n        </ax-prefix>\n      </ax-button-item>\n      }\n    </ax-button-item-list>\n  </ax-dropdown-panel>\n</ax-button>" }]
+        }] });
+
+class AXMLocalizationManagementModuleMenuProvider {
+    constructor() {
+        this.translateService = inject(AXTranslationService);
+    }
+    async items() {
+        const scope = 'localization-management'; // The scope used for translation lookup
+        return [
+            {
+                items: [
+                    {
+                        text: await this.translateService.translateAsync('localizationManagement', { scope }),
+                        icon: 'fa-solid fa-globe-stand',
+                        type: 'menu',
+                        priority: 9100,
+                        data: {
+                        // requiredPermission: 'demo.admin.settings',
+                        },
+                        children: [
+                            {
+                                priority: 9001,
+                                icon: 'fa-solid fa-language',
+                                text: await this.translateService.translateAsync('languageDefinition', { scope }),
+                                path: '/demo/m/localization-management/e/language/list',
+                            },
+                            {
+                                priority: 9003,
+                                icon: 'fa-solid fa-clock-one-thirty',
+                                text: await this.translateService.translateAsync('Time Zone', { scope }),
+                                path: '/demo/m/localization-management/e/time-zone/list',
+                            },
+                            {
+                                priority: 9003,
+                                icon: 'fa-solid fa-mountain-sun',
+                                text: await this.translateService.translateAsync('Culture', { scope }),
+                                path: '/demo/m/localization-management/e/culture/list',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+    }
+}
+
+class AXMTimeZoneService extends AXMEntityCrudServiceImpl {
+}
+class AXMTimeZoneServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(TIMEZONE_SOURCE_NAME);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTimeZoneServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTimeZoneServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTimeZoneServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function timeZoneEntityFactory(injector) {
+    const dataService = injector.get(AXMTimeZoneService);
+    const entityDef = {
+        module: 'localization-management',
+        name: 'time-zone',
+        source: 'localizationManagement.timeZone',
+        title: 'Time Zone',
+        formats: {
+            individual: 'Time Zone',
+            plural: 'Time Zones',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: 'Time Zone',
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'name',
+                title: 'Name',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'gmtOffset',
+                title: 'GMT Offset',
+                groupId: 'section',
+                schema: {
+                    dataType: 'integer',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'gmtOffsetName',
+                title: 'GMT',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'abbreviation',
+                title: 'Abbreviation',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'tzName',
+                title: 'TZ',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'gmtOffsetName' }, { name: 'abbreviation' }, { name: 'tzName' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return Promise.resolve({});
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return Promise.resolve();
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return Promise.resolve();
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'gmtOffset',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'gmtOffsetName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'abbreviation',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'tzName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: 'Details',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 'All Items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var timeZone_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    timeZoneEntityFactory: timeZoneEntityFactory
+});
+
+class AXMCultureService extends AXMEntityCrudServiceImpl {
+}
+class AXMCultureServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(CULTURE_SOURCE_NAME);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCultureServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCultureServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCultureServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function cultureEntityFactory(injector) {
+    const dataService = injector.get(AXMCultureService);
+    const entityDef = {
+        module: 'localization-management',
+        name: 'culture',
+        source: 'localizationManagement.culture',
+        title: 'Culture',
+        formats: {
+            individual: 'Culture',
+            plural: 'Cultures',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'culture',
+                title: 'Culture',
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'language',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'code',
+                title: 'Code',
+                groupId: 'language',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'code' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
+                    dataService.insertOne(entity);
+                    return Promise.resolve(entity);
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    await await dataService.deleteOne(id);
+                    return Promise.resolve();
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            await dataService.updateOne(data.id, data);
+                            resolve(data);
+                        }, 1000);
+                    });
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'language',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'language',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'language',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: 'Create New',
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 'Delete Items',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 'Details',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 'Delete',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 'All Items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var culture_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    cultureEntityFactory: cultureEntityFactory
+});
+
+class AXMLocalizationManagementModule {
+    constructor(appInitService, injector) {
+        const service = injector.get(AXPLocalizationStoreService);
+        appInitService.registerTask({
+            name: 'Settings',
+            statusText: 'Loading Settings ...',
+            run: async () => {
+                await service.loadSetting();
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalizationManagementModule, deps: [{ token: i1$1.AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalizationManagementModule, imports: [i1$1.AXPComponentSlotModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalizationManagementModule, providers: [
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMLocalizationManagementModuleMenuProvider,
+                multi: true
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMLocalizationManagementModuleEntityLoader,
+                multi: true
+            },
+            {
+                provide: AXMLanguageService,
+                useClass: AXMLanguageServiceImpl
+            },
+            {
+                provide: AXMTimeZoneService,
+                useClass: AXMTimeZoneServiceImpl
+            },
+            {
+                provide: AXMCultureService,
+                useClass: AXMCultureServiceImpl
+            }
+        ], imports: [AXPComponentSlotModule.forChild({
+                'header-end': [
+                    {
+                        name: 'language',
+                        component: AXMLanguageSlotComponent
+                    }
+                ]
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalizationManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPComponentSlotModule.forChild({
+                            'header-end': [
+                                {
+                                    name: 'language',
+                                    component: AXMLanguageSlotComponent
+                                }
+                            ]
+                        })
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMLocalizationManagementModuleMenuProvider,
+                            multi: true
+                        },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMLocalizationManagementModuleEntityLoader,
+                            multi: true
+                        },
+                        {
+                            provide: AXMLanguageService,
+                            useClass: AXMLanguageServiceImpl
+                        },
+                        {
+                            provide: AXMTimeZoneService,
+                            useClass: AXMTimeZoneServiceImpl
+                        },
+                        {
+                            provide: AXMCultureService,
+                            useClass: AXMCultureServiceImpl
+                        }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i1$1.AXPAppStartUpService }, { type: i0.Injector }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMCultureService, AXMCultureServiceImpl, AXMLanguageService, AXMLanguageServiceImpl, AXMLocalizationManagementModule, AXMLocalizationManagementModuleEntityLoader, AXMLocalizationManagementModuleMenuProvider, AXMTimeZoneService, AXMTimeZoneServiceImpl, CULTURE_SOURCE_NAME, LANGUAGE_SOURCE_NAME, TIMEZONE_SOURCE_NAME, cultureEntityFactory, languageEntityFactory, timeZoneEntityFactory };
+//# sourceMappingURL=acorex-modules-localization-management.mjs.map