@acorex/modules 18.2.0 → 18.2.2

package/fesm2022/{acorex-modules-template-management.mjs → acorex-modules-text-template-management.mjs}

@@ -1,200 +1,75 @@
-import { AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
-import * as i0 from '@angular/core';
-import { inject, Injector, Injectable, NgModule } from '@angular/core';
-import { AXMEntityCrudServiceImpl, AXP_MENU_PROVIDER, AXPEntityQueryType, AXPEntityCommandScope } from '@acorex/platform/common';
-import { AXTranslationService } from '@acorex/core/translation';
+import { AXMEntityCrudServiceImpl, AXPEntityCommandScope, AXPEntityQueryType, AXPSettingDefinitionItemType, AXP_MENU_PROVIDER, AXP_SETTING_PROVIDER } from '@acorex/platform/common';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import * as i0 from '@angular/core';
+import { Injectable, NgModule, inject, Injector } from '@angular/core';
+import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 
-class AXMTemplateModuleEntityLoader {
-    constructor() {
-        this.injector = inject(Injector);
-    }
-    async get(moduleName, entityName) {
-        return new Promise(async (resolve) => {
-            switch (entityName) {
-                case 'template': {
-                    const entity = (await Promise.resolve().then(function () { return textTemplate_entity; })).templateEntityFactory;
-                    resolve(entity(this.injector));
-                    break;
-                }
-                case 'variable': {
-                    const entity = (await Promise.resolve().then(function () { return templateVariable_entity; })).textTemplateVariableEntityFactory;
-                    resolve(entity(this.injector));
-                    break;
-                }
-                case 'category': {
-                    const entity = (await Promise.resolve().then(function () { return category_entity; })).textTemplateCategoryEntityFactory;
-                    resolve(entity(this.injector));
-                    break;
-                }
-                default:
-                    resolve(null);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateModuleEntityLoader, decorators: [{
-            type: Injectable
-        }] });
-
-const TEMPLATE_SOURCE_NAME = 'template-management.template';
-const CATEGORY_SOURCE_NAME = 'template-management.category';
+const AXMTextTemplateManagementModuleConst = {
+    moduleName: 'textTemplateManagement',
+    moduleRoute: 'text-template-management',
+    i18n: 'text-template-management',
+    categoryEntity: 'Category',
+    templateEntity: 'Template',
+};
 
-class AXMTextTemplateService extends AXMEntityCrudServiceImpl {
+class AXMTextTemplateManagementCategoryEntityService extends AXMEntityCrudServiceImpl {
 }
-class AXMTextTemplateServiceImpl extends AXMEntityCrudServiceImpl {
+class AXMTextTemplateManagementCategoryEntityServiceImpl extends AXMTextTemplateManagementCategoryEntityService {
     constructor() {
-        super(TEMPLATE_SOURCE_NAME);
+        super(`${AXMTextTemplateManagementModuleConst.moduleName}.${AXMTextTemplateManagementModuleConst.categoryEntity}`);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateServiceImpl }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementCategoryEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementCategoryEntityServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateServiceImpl, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementCategoryEntityServiceImpl, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 
-class AXMTextTemplateCategoryService extends AXMEntityCrudServiceImpl {
-}
-class AXMTextTemplateCategoryServiceImpl extends AXMEntityCrudServiceImpl {
-    constructor() {
-        super(CATEGORY_SOURCE_NAME);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateCategoryServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateCategoryServiceImpl }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateCategoryServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class AXMTextTemplateManagmentModuleMenuProvider {
-    constructor() {
-        this.translateService = inject(AXTranslationService);
-    }
-    async items() {
-        const scope = 'platform'; // Scope used for translation lookup
-        return [
-            {
-                items: [
-                    {
-                        priority: 9001,
-                        text: await this.translateService.translateAsync('textTemplateManagement', { scope }),
-                        icon: 'fa-solid fa-code',
-                        data: {
-                        // requiredPermission: 'demo.admin.settings',
-                        },
-                        children: [
-                            {
-                                text: await this.translateService.translateAsync('template', { scope }),
-                                path: '/demo/m/template-management/e/template/list',
-                                icon: 'fa-solid fa-file-code',
-                                data: {
-                                // requiredPermission: '',
-                                },
-                            },
-                            {
-                                text: await this.translateService.translateAsync('category', { scope }),
-                                path: '/demo/m/template-management/e/category/list',
-                                icon: 'fa-solid fa-layer-group',
-                                data: {
-                                // requiredPermission: '',
-                                },
-                            },
-                        ],
-                    },
-                ],
-            },
-        ];
-    }
-}
-
-class AXMTemplateManagementModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateManagementModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateManagementModule, providers: [
-            {
-                provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMTemplateModuleEntityLoader,
-                multi: true,
-            },
-            {
-                provide: AXP_MENU_PROVIDER,
-                useClass: AXMTextTemplateManagmentModuleMenuProvider,
-                multi: true
-            },
-            {
-                provide: AXMTextTemplateService,
-                useClass: AXMTextTemplateServiceImpl,
-            },
-            {
-                provide: AXMTextTemplateCategoryService,
-                useClass: AXMTextTemplateCategoryServiceImpl,
-            },
-        ] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTemplateManagementModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [],
-                    exports: [],
-                    declarations: [],
-                    providers: [
-                        {
-                            provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMTemplateModuleEntityLoader,
-                            multi: true,
-                        },
-                        {
-                            provide: AXP_MENU_PROVIDER,
-                            useClass: AXMTextTemplateManagmentModuleMenuProvider,
-                            multi: true
-                        },
-                        {
-                            provide: AXMTextTemplateService,
-                            useClass: AXMTextTemplateServiceImpl,
-                        },
-                        {
-                            provide: AXMTextTemplateCategoryService,
-                            useClass: AXMTextTemplateCategoryServiceImpl,
-                        },
-                    ],
-                }]
-        }] });
-
-async function textTemplateCategoryEntityFactory(injector) {
-    const dataService = injector.get(AXMTextTemplateCategoryService);
+async function categoryFactory(injector) {
+    const dataService = injector.get(AXMTextTemplateManagementCategoryEntityService);
+    const moduleName = AXMTextTemplateManagementModuleConst.moduleName;
+    const scope = `#${moduleName}`;
     const entityDef = {
-        module: 'template-management',
-        name: 'textTemplateCategory',
-        source: 'template-management.textTemplateCategory',
-        title: 'Category',
+        module: moduleName,
+        name: AXMTextTemplateManagementModuleConst.categoryEntity,
+        source: '',
+        title: `t("category", { scope: "common" })`,
         formats: {
-            individual: 'Category',
-            plural: 'Categories',
+            individual: 't("category")',
+            plural: 't("categories", { scope: "common" })',
         },
         relatedEntities: [],
         groups: [
             {
                 id: 'category',
-                title: 'Category',
+                title: 't("category", { scope: "common" })',
             },
         ],
         properties: [
             {
                 name: 'name',
-                title: 'Name',
+                title: 't("name", { scope: "common" })',
                 groupId: 'category',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'title',
-                title: 'Title',
+                title: 't("title", { scope: "common" })',
                 groupId: 'category',
                 schema: {
                     dataType: 'string',
@@ -202,6 +77,16 @@ async function textTemplateCategoryEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
         ],
         columns: [{ name: 'name' }, { name: 'title' }],
@@ -242,7 +127,7 @@ async function textTemplateCategoryEntityFactory(injector) {
             },
             list: {
                 execute: async (e) => {
-                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter, sort: e.sort });
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -348,28 +233,28 @@ async function textTemplateCategoryEntityFactory(injector) {
                 list: {
                     actions: [
                         {
-                            title: 'Create New',
+                            title: `t("create",{scope: "common"}) t("category",{scope: "common"})`,
                             command: 'create-entity',
                             priority: 'primary',
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
                         {
-                            title: 'Delete Items',
+                            title: 't("deleteItems", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
                             scope: AXPEntityCommandScope.Selected,
                         },
                         {
-                            title: 'Details',
+                            title: 't("detail", { scope: "common" })',
                             command: 'open-entity',
                             priority: 'primary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
                         {
-                            title: 'Delete',
+                            title: 't("delete", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
@@ -379,7 +264,7 @@ async function textTemplateCategoryEntityFactory(injector) {
                     views: [
                         {
                             name: 'all',
-                            title: 'All Items',
+                            title: 't("allItem", { scope: "common" })',
                             fixed: true,
                             columns: [],
                             conditions: [],
@@ -393,37 +278,56 @@ async function textTemplateCategoryEntityFactory(injector) {
     return entityDef;
 }
 
-var category_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    textTemplateCategoryEntityFactory: textTemplateCategoryEntityFactory
-});
+class AXMTextTemplateManagementCategoryEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementCategoryEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementCategoryEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementCategoryEntityModule, providers: [
+            {
+                provide: AXMTextTemplateManagementCategoryEntityService,
+                useClass: AXMTextTemplateManagementCategoryEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementCategoryEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMTextTemplateManagementCategoryEntityService,
+                            useClass: AXMTextTemplateManagementCategoryEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
 
-async function templateEntityFactory(injector) {
-    const dataService = injector.get(AXMTextTemplateService);
+class AXMTextTemplateManagementTemplateEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMTextTemplateManagementTemplateEntityServiceImpl extends AXMTextTemplateManagementTemplateEntityService {
+    constructor() {
+        super(`${AXMTextTemplateManagementModuleConst.moduleName}.${AXMTextTemplateManagementModuleConst.templateEntity}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementTemplateEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementTemplateEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementTemplateEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function templateFactory(injector) {
+    const dataService = injector.get(AXMTextTemplateManagementTemplateEntityService);
     const entityDef = {
-        module: 'template-management',
-        name: 'template',
-        source: 'templateManagement.template',
+        module: AXMTextTemplateManagementModuleConst.moduleName,
+        name: AXMTextTemplateManagementModuleConst.templateEntity,
+        source: '',
         title: 'Templates',
         formats: {
             individual: 'Template',
             plural: 'Templates',
         },
-        relatedEntities: [
-            {
-                entity: 'template-management.variable',
-                columns: ['name', 'title', 'type', 'requirement'],
-                conditions: [
-                    {
-                        name: 'globalTemplateId',
-                        operator: {
-                            type: 'equal',
-                        },
-                        value: 'id',
-                    },
-                ],
-            },
-        ],
+        relatedEntities: [],
         groups: [
             {
                 id: 'template',
@@ -441,6 +345,11 @@ async function templateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'title',
@@ -452,6 +361,11 @@ async function templateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'content',
@@ -463,9 +377,14 @@ async function templateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.richText,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
-                name: 'category.id',
+                name: 'categoryId',
                 title: 'Category',
                 groupId: 'template',
                 schema: {
@@ -474,21 +393,18 @@ async function templateEntityFactory(injector) {
                         type: AXPWidgetsCatalog.lookup,
                         options: {
                             entity: 'template-management.category',
-                            expose: 'category',
+                            expose: [
+                                { source: 'id', target: 'categoryId' },
+                                { source: 'title', target: 'category.title' },
+                            ],
                         },
                     },
                 },
-            },
-            {
-                name: 'category.title',
-                title: 'Category Title',
-                groupId: 'template',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
+                validations: [
+                    {
+                        rule: 'required',
                     },
-                },
+                ],
             },
             {
                 name: 'type',
@@ -510,9 +426,19 @@ async function templateEntityFactory(injector) {
                         },
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
         ],
-        columns: [{ name: 'name' }, { name: 'title' }, { name: 'category.title' }, { name: 'type' }],
+        columns: [
+            { name: 'name' },
+            { name: 'title' },
+            { name: 'categoryId', options: { dataPath: 'category.title' } },
+            { name: 'type' },
+        ],
         commands: {
             create: {
                 execute: async (data) => {
@@ -595,7 +521,7 @@ async function templateEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'category.id',
+                            name: 'categoryId',
                             layout: {
                                 positions: {
                                     lg: {
@@ -654,7 +580,7 @@ async function templateEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'category.id',
+                            name: 'categoryId',
                             layout: {
                                 positions: {
                                     lg: {
@@ -730,6 +656,16 @@ async function templateEntityFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'categoryId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
                     ],
                     actions: [],
                 },
@@ -781,324 +717,199 @@ async function templateEntityFactory(injector) {
     return entityDef;
 }
 
-var textTemplate_entity = /*#__PURE__*/Object.freeze({
+class AXMTextTemplateManagementTemplateEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementTemplateEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementTemplateEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementTemplateEntityModule, providers: [
+            {
+                provide: AXMTextTemplateManagementTemplateEntityService,
+                useClass: AXMTextTemplateManagementTemplateEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementTemplateEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMTextTemplateManagementTemplateEntityService,
+                            useClass: AXMTextTemplateManagementTemplateEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    templateEntityFactory: templateEntityFactory
+    AXMTextTemplateManagementCategoryEntityModule: AXMTextTemplateManagementCategoryEntityModule,
+    AXMTextTemplateManagementCategoryEntityService: AXMTextTemplateManagementCategoryEntityService,
+    AXMTextTemplateManagementCategoryEntityServiceImpl: AXMTextTemplateManagementCategoryEntityServiceImpl,
+    AXMTextTemplateManagementTemplateEntityModule: AXMTextTemplateManagementTemplateEntityModule,
+    AXMTextTemplateManagementTemplateEntityService: AXMTextTemplateManagementTemplateEntityService,
+    AXMTextTemplateManagementTemplateEntityServiceImpl: AXMTextTemplateManagementTemplateEntityServiceImpl,
+    categoryFactory: categoryFactory,
+    templateFactory: templateFactory
 });
 
-async function textTemplateVariableEntityFactory(injector) {
-    const dataService = injector.get(AXMTextTemplateService);
-    const entityDef = {
-        module: 'template-management',
-        name: 'textTemplateVariable',
-        source: 'template-management.variable',
-        title: 'Template Variables',
-        formats: {
-            individual: 'TemplateVariable',
-            plural: 'TemplateVariables'
-        },
-        relatedEntities: [],
-        groups: [
-            {
-                id: 'templateVariable',
-                title: 'TemplateVariable'
+class AXMTextTemplateManagementModuleEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == AXMTextTemplateManagementModuleConst.moduleName) {
+            switch (entityName) {
+                case AXMTextTemplateManagementModuleConst.templateEntity: {
+                    const entity = (await Promise.resolve().then(function () { return index; })).templateFactory;
+                    return entity(this.injector);
+                }
+                case AXMTextTemplateManagementModuleConst.categoryEntity: {
+                    const entity = (await Promise.resolve().then(function () { return index; })).categoryFactory;
+                    return entity(this.injector);
+                }
             }
-        ],
-        properties: [
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementModuleEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementModuleEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementModuleEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMTextTemplateManagementModuleMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const scope = AXMTextTemplateManagementModuleConst.i18n;
+        const moduleName = AXMTextTemplateManagementModuleConst.moduleName;
+        context.addItems([
             {
-                name: 'name',
-                title: 'Name',
-                groupId: 'templateVariable',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text
-                    }
-                }
+                priority: 9001,
+                text: `t('module-name', {scope: ${scope}})`,
+                icon: 'fa-solid fa-code',
+                data: {
+                // requiredPermission: 'demo.admin.settings',
+                },
+                children: [
+                    {
+                        text: `t('templates', {scope: ${scope}})`,
+                        path: this.entityService.createPath(moduleName, AXMTextTemplateManagementModuleConst.templateEntity),
+                        icon: 'fa-solid fa-file-code',
+                        priority: 1,
+                    },
+                    {
+                        text: `t('category', {scope: ${scope}})`,
+                        path: this.entityService.createPath(moduleName, AXMTextTemplateManagementModuleConst.categoryEntity),
+                        icon: 'fa-solid fa-layer-group',
+                        priority: 2,
+                    },
+                ],
             },
+        ]);
+    }
+}
+
+class AXMTextTemplateManagementModuleSettingProvider {
+    async provide(context) {
+        const scope = AXMTextTemplateManagementModuleConst.i18n;
+        const moduleName = AXMTextTemplateManagementModuleConst.moduleName;
+        context.addItems([
             {
-                name: 'title',
-                title: 'Title',
-                groupId: 'templateVariable',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text
-                    }
-                }
+                name: 'text-template-management',
+                type: AXPSettingDefinitionItemType.Group,
+                title: 'Text Template Management',
+                singles: [
+                    {
+                        name: 'TTM-isEnable',
+                        dataType: 'boolean',
+                        isEncrypted: false,
+                        isInherited: false,
+                        scope: 'T',
+                        title: 'Text Template Management Active',
+                        isRequired: true,
+                        type: AXPSettingDefinitionItemType.Single,
+                    },
+                ],
+                groups: [
+                    {
+                        name: 'text-template-management-category',
+                        type: AXPSettingDefinitionItemType.Group,
+                        title: 'Category',
+                        singles: [
+                            {
+                                name: 'TTMC-isEnable',
+                                dataType: 'boolean',
+                                isEncrypted: false,
+                                isInherited: false,
+                                scope: 'T',
+                                title: 'Text Template Category Management Active',
+                                isRequired: true,
+                                type: AXPSettingDefinitionItemType.Single,
+                            },
+                        ],
+                        groups: [],
+                    },
+                ],
             },
+        ]);
+    }
+}
+
+class AXMTextTemplateManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementModule, imports: [AXMTextTemplateManagementTemplateEntityModule, AXMTextTemplateManagementCategoryEntityModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementModule, providers: [
             {
-                name: 'type',
-                title: 'Type',
-                groupId: 'templateVariable',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.select
-                    }
-                }
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMTextTemplateManagementModuleMenuProvider,
+                multi: true,
             },
             {
-                name: 'required',
-                title: 'required',
-                groupId: 'templateVariable',
-                schema: {
-                    dataType: 'boolean',
-                    interface: {
-                        type: AXPWidgetsCatalog.toggle
-                    }
-                }
-            }
-        ],
-        columns: [{ name: 'name' }, { name: 'title' }, { name: 'required' }],
-        commands: {
-            create: {
-                execute: async (data) => {
-                    const item = await dataService.getOne(data.globalTemplateId);
-                    (item.templateVariables ??= []).push(data);
-                    return await dataService.updateOne(data.globalTemplateId, item);
-                }
-            },
-            delete: {
-                execute: async (id) => {
-                    //    await await dataService.templateVariableDataProvider.deleteOne(id);
-                    return Promise.resolve();
-                }
+                provide: AXP_SETTING_PROVIDER,
+                useClass: AXMTextTemplateManagementModuleSettingProvider,
+                multi: true,
             },
-            update: {
-                execute: async (data) => {
-                    console.log(data);
-                    return new Promise((resolve) => {
-                        setTimeout(async () => {
-                            //   await dataService.templateVariableDataProvider.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
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMTextTemplateManagementModuleEntityProvider,
+                multi: true,
             },
-            list: {
-                execute: async (e) => {
-                    if (e.filter != null && e.filter.filters != null && e.filter.filters[0].value != null) {
-                        const parentItem = await dataService.getOne(e.filter?.filters[0].value);
-                        return {
-                            totalCount: parentItem.templateVariables.length,
-                            items: parentItem.templateVariables
-                        };
-                    }
-                    else {
-                        //TODO throw exception
-                        return [];
-                    }
-                },
-                type: AXPEntityQueryType.List
-            }
-        },
-        interfaces: {
-            master: {
-                create: {
-                    sections: [
-                        {
-                            id: 'templateVariable'
-                        }
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        },
-                        {
-                            name: 'required',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        }
-                    ]
-                },
-                update: {
-                    sections: [
-                        {
-                            id: 'templateVariable'
-                        },
-                        {
-                            id: 'schema'
-                        },
-                        {
-                            id: 'interface'
-                        }
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        },
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        },
-                        {
-                            name: 'schema.nullable',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        },
-                        {
-                            name: 'required',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        }
-                    ]
-                },
-                single: {
-                    title: '{{title}}',
-                    sections: [
-                        {
-                            id: 'templateVariable'
-                        }
-                    ],
-                    properties: [
-                        {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
-                        },
+        ], imports: [AXMTextTemplateManagementTemplateEntityModule, AXMTextTemplateManagementCategoryEntityModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMTextTemplateManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [AXMTextTemplateManagementTemplateEntityModule, AXMTextTemplateManagementCategoryEntityModule],
+                    exports: [],
+                    declarations: [],
+                    providers: [
                         {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6
-                                    }
-                                }
-                            }
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMTextTemplateManagementModuleMenuProvider,
+                            multi: true,
                         },
                         {
-                            name: 'required',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12
-                                    }
-                                }
-                            }
-                        }
-                    ],
-                    actions: []
-                },
-                list: {
-                    actions: [
-                        {
-                            title: 'Create New',
-                            command: 'create-entity',
-                            priority: 'primary',
-                            type: 'create',
-                            scope: AXPEntityCommandScope.TypeLevel
+                            provide: AXP_SETTING_PROVIDER,
+                            useClass: AXMTextTemplateManagementModuleSettingProvider,
+                            multi: true,
                         },
                         {
-                            title: 'Delete Items',
-                            command: 'delete-entity',
-                            priority: 'primary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Selected
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMTextTemplateManagementModuleEntityProvider,
+                            multi: true,
                         },
-                        // {
-                        //   title: 'Update',
-                        //   command: 'update-entity',
-                        //   priority: 'primary',
-                        //   type: 'view',
-                        //   scope: AXPEntityCommandScope.Individual
-                        // },
-                        {
-                            title: 'Delete',
-                            command: 'delete-entity',
-                            priority: 'primary',
-                            type: 'delete',
-                            scope: AXPEntityCommandScope.Individual
-                        }
                     ],
-                    views: [
-                        {
-                            name: 'all',
-                            title: 'All Items',
-                            fixed: true,
-                            columns: [],
-                            conditions: [],
-                            sorts: []
-                        }
-                    ]
-                }
-            }
-        }
-    };
-    return entityDef;
-}
-
-var templateVariable_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    textTemplateVariableEntityFactory: textTemplateVariableEntityFactory
-});
+                }]
+        }] });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMTemplateManagementModule, AXMTemplateModuleEntityLoader, AXMTextTemplateCategoryService, AXMTextTemplateCategoryServiceImpl, AXMTextTemplateService, AXMTextTemplateServiceImpl, CATEGORY_SOURCE_NAME, TEMPLATE_SOURCE_NAME, templateEntityFactory, textTemplateCategoryEntityFactory, textTemplateVariableEntityFactory };
-//# sourceMappingURL=acorex-modules-template-management.mjs.map
+export { AXMTextTemplateManagementCategoryEntityModule, AXMTextTemplateManagementCategoryEntityService, AXMTextTemplateManagementCategoryEntityServiceImpl, AXMTextTemplateManagementModule, AXMTextTemplateManagementModuleConst, AXMTextTemplateManagementModuleEntityProvider, AXMTextTemplateManagementModuleMenuProvider, AXMTextTemplateManagementTemplateEntityModule, AXMTextTemplateManagementTemplateEntityService, AXMTextTemplateManagementTemplateEntityServiceImpl, categoryFactory, templateFactory };
+//# sourceMappingURL=acorex-modules-text-template-management.mjs.map