@acorex/modules 18.2.0 → 18.2.2

package/fesm2022/acorex-modules-form-template-management.mjs

@@ -0,0 +1,1135 @@
+import { AXMEntityCrudServiceImpl, AXPEntityCommandScope, AXPEntityQueryType, AXPWorkflowNavigateAction, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY, AXPWidgetsModule, AXP_TEMPLATE_WIDGET_PROVIDER } from '@acorex/platform/widgets';
+import * as i0 from '@angular/core';
+import { Injectable, NgModule, inject, Injector, ChangeDetectionStrategy, Component } from '@angular/core';
+import * as i1$1 from '@angular/router';
+import { RouterModule } from '@angular/router';
+import * as i2$1 from '@acorex/platform/layout/builder';
+import { AXPWidgetsCatalog, AXPWidgetComponent, AXP_WIDGETS_LAYOUT_GROUP, AXPLayoutBuilderModule } from '@acorex/platform/layout/builder';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2 from '@acorex/core/translation';
+import { AXTranslationModule } from '@acorex/core/translation';
+import * as i3 from '@acorex/platform/workflow';
+import { AXPWorkflowService, AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { AXPDesignerConnector } from '@acorex/platform/layout/designer';
+
+const AXMFormTemplateManagementModuleConst = {
+    moduleName: 'FormTemplateManagement',
+    moduleRoute: 'form-template-management',
+    i18n: 'form-template-management',
+    categoryEntity: 'Category',
+    templateEntity: 'Template',
+};
+
+class AXMFormTemplateManagementCategoryEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMFormTemplateManagementCategoryEntityServiceImpl extends AXMFormTemplateManagementCategoryEntityService {
+    constructor() {
+        super(`${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.categoryEntity}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementCategoryEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementCategoryEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementCategoryEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function factory$1(injector) {
+    const dataService = injector.get(AXMFormTemplateManagementCategoryEntityService);
+    const i18n = AXMFormTemplateManagementModuleConst.i18n;
+    const entityDef = {
+        module: AXMFormTemplateManagementModuleConst.moduleName,
+        name: AXMFormTemplateManagementModuleConst.categoryEntity,
+        source: '',
+        title: `t("category", { scope: "common" })`,
+        formats: {
+            individual: `t("category", { scope: "common" })`,
+            plural: `t("categories", { scope: "common" })`,
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: `t("category", { scope: "common" })`,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: 't("title", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter, sort: e.sort });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 't("allItem", { scope: "common" })',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var category_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    factory: factory$1
+});
+
+class AXMFormTemplateManagementCategoryEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementCategoryEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementCategoryEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementCategoryEntityModule, providers: [
+            {
+                provide: AXMFormTemplateManagementCategoryEntityService,
+                useClass: AXMFormTemplateManagementCategoryEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementCategoryEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMFormTemplateManagementCategoryEntityService,
+                            useClass: AXMFormTemplateManagementCategoryEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMFormTemplateManagementTemplateEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMFormTemplateManagementTemplateEntityServiceImpl extends AXMFormTemplateManagementTemplateEntityService {
+    constructor() {
+        super(`${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.templateEntity}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementTemplateEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementTemplateEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementTemplateEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function factory(injector) {
+    const dataService = injector.get(AXMFormTemplateManagementTemplateEntityService);
+    const i18n = AXMFormTemplateManagementModuleConst.i18n;
+    const entityDef = {
+        module: AXMFormTemplateManagementModuleConst.moduleName,
+        name: AXMFormTemplateManagementModuleConst.templateEntity,
+        source: '',
+        title: `t("template",{scope:"${i18n}"})`,
+        formats: {
+            individual: `t("template",{scope:"${i18n}"})`,
+            plural: `t("templates",{scope:"${i18n}"})`,
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: `t("information",{scope:"common"})`,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    filter: {
+                        inline: { enabled: true },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: 't("title", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    filter: {
+                        inline: { enabled: true },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'categoryId',
+                title: 't("category", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.categoryEntity}`,
+                            expose: [
+                                { source: 'id', target: 'categoryId' },
+                                { source: 'title', target: 'category.title' },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'type',
+                title: `t("template-type",{scope:"${i18n}"})`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'value',
+                            textField: 'title',
+                            defaultValue: '10',
+                            dataSource: [
+                                { value: 10, title: 'Form Template' },
+                                { value: 20, title: 'Widgets Template' },
+                            ],
+                            multiple: false,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'template',
+                title: `t("template",{scope:"${i18n}"})`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.templateDesigner,
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'name' },
+            { name: 'title' },
+            { name: 'type' },
+            { name: 'categoryId', options: { dataPath: 'category.title' } },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                order: 10,
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryId',
+                            layout: {
+                                order: 20,
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            id: 'template',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'template',
+                            layout: {
+                                label: {
+                                    visible: false,
+                                },
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-form-template',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 't("allItem", { scope: "common" })',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        },
+                        {
+                            name: 'forms',
+                            title: `t("forms", { scope: "${i18n}" })`,
+                            fixed: true,
+                            columns: [],
+                            conditions: [
+                                {
+                                    name: 'type.value',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 10,
+                                },
+                            ],
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        },
+                        {
+                            name: 'widgets',
+                            title: `t("widgets", { scope: "${i18n}" })`,
+                            fixed: true,
+                            columns: [],
+                            conditions: [
+                                {
+                                    name: 'type.value',
+                                    operator: {
+                                        type: 'equal',
+                                    },
+                                    value: 20,
+                                },
+                            ],
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var template_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    factory: factory
+});
+
+class AXMFormTemplateManagementTemplateEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementTemplateEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementTemplateEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementTemplateEntityModule, providers: [
+            {
+                provide: AXMFormTemplateManagementTemplateEntityService,
+                useClass: AXMFormTemplateManagementTemplateEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementTemplateEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMFormTemplateManagementTemplateEntityService,
+                            useClass: AXMFormTemplateManagementTemplateEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+class AXMFormTemplateManagementModuleEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == AXMFormTemplateManagementModuleConst.moduleName) {
+            switch (entityName) {
+                case AXMFormTemplateManagementModuleConst.categoryEntity:
+                    return (await Promise.resolve().then(function () { return category_entity; })).factory(this.injector);
+                case AXMFormTemplateManagementModuleConst.templateEntity:
+                    return (await Promise.resolve().then(function () { return template_entity; })).factory(this.injector);
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModuleEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModuleEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModuleEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMFormTemplateManagementModuleMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const scope = AXMFormTemplateManagementModuleConst.i18n;
+        const moduleName = AXMFormTemplateManagementModuleConst.moduleName;
+        context.addItems([
+            {
+                priority: 9001,
+                text: `t('module-name', {scope: ${scope}})`,
+                icon: 'fa-solid fa-file-invoice',
+                children: [
+                    {
+                        text: `t("categories", { scope: "common" })`,
+                        path: this.entityService.createPath(moduleName, AXMFormTemplateManagementModuleConst.categoryEntity),
+                        priority: 1,
+                    },
+                    {
+                        text: `t('templates', {scope: ${scope}})`,
+                        path: this.entityService.createPath(moduleName, AXMFormTemplateManagementModuleConst.templateEntity),
+                        priority: 2,
+                    },
+                ],
+            },
+        ]);
+    }
+}
+
+class AXPTemplateDesignerWidgetViewComponent extends AXPWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.workflow = inject(AXPWorkflowService);
+    }
+    async handleClick() {
+        await this.workflow.execute('design-form-template', { data: { id: this.extractValue('id') } });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPTemplateDesignerWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.0", type: AXPTemplateDesignerWidgetViewComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <span
+      class="ax-underline ax-decoration-dotted  ax-underline-offset-8 hover:ax-text-primary-500 ax-cursor-pointer"
+      (click)="handleClick()"
+    >
+      {{ 'edit-template' | translate : { scope: 'form-template-management' } | async }}
+    </span>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i2.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPTemplateDesignerWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <span
+      class="ax-underline ax-decoration-dotted  ax-underline-offset-8 hover:ax-text-primary-500 ax-cursor-pointer"
+      (click)="handleClick()"
+    >
+      {{ 'edit-template' | translate : { scope: 'form-template-management' } | async }}
+    </span>
+  `,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [CommonModule, AXButtonModule, AXTranslationModule],
+                }]
+        }] });
+
+var templateDesignerWidgetView_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPTemplateDesignerWidgetViewComponent: AXPTemplateDesignerWidgetViewComponent
+});
+
+const AXPTemplateDesignerWidget = {
+    name: "template-designer",
+    title: "Template Designer",
+    icon: "fa-solid fa-square",
+    type: 'editor',
+    group: AXP_WIDGETS_LAYOUT_GROUP,
+    visible: false,
+    properties: [
+        AXP_NAME_PROPERTY,
+        AXP_DATA_PATH_PROPERTY,
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return templateDesignerWidgetView_component; }).then((c) => c.AXPTemplateDesignerWidgetViewComponent),
+        },
+        edit: {
+            component: () => Promise.resolve().then(function () { return templateDesignerWidgetView_component; }).then((c) => c.AXPTemplateDesignerWidgetViewComponent),
+        }
+    }
+};
+
+const AXMCreateFormTemplateWorkflow = {
+    startStepId: 'create-form-template',
+    steps: {
+        "create-form-template": {
+            action: 'start-workflow',
+            input: {
+                workflow: "create-entity",
+                context: {
+                    redirect: true,
+                    entity: `${AXMFormTemplateManagementModuleConst.moduleName}.${AXMFormTemplateManagementModuleConst.templateEntity}`,
+                }
+            },
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'get-template-confirmaton',
+                },
+            ],
+        },
+        "get-template-confirmaton": {
+            action: 'show-prompt-dialog',
+            input: {
+                title: 'Confirm Action',
+                message: `Would you like to proceed with starting template design?`,
+                type: 'info',
+            },
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'template-design',
+                },
+            ],
+        },
+        "template-design": {
+            action: 'open-form-template-designer',
+        },
+    },
+};
+
+class AXPDesignerConnectorImpl extends AXPDesignerConnector {
+    constructor() {
+        super(...arguments);
+        this.service = inject(AXMFormTemplateManagementTemplateEntityService);
+        //#endregion
+    }
+    //#region Save and load Widgets
+    async save(id, content) {
+        const item = await this.service.getOne(id);
+        if (item) {
+            await this.service.updateOne(id, { template: content.json });
+        }
+        else {
+            throw Error("Invalid Id");
+        }
+    }
+    async saveAs(content) {
+        throw Error("Not Implemented");
+    }
+    async load(id) {
+        const item = await this.service.getOne(id);
+        if (item) {
+            return item.template;
+        }
+        else {
+            throw Error("Invalid Id");
+        }
+    }
+}
+
+class AXMOpenFormTemplateDesignerAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.navigation = inject(AXPWorkflowNavigateAction);
+    }
+    async execute(context) {
+        const { id } = context.getVariable('data');
+        context.setVariable('payload', {
+            commands: `/forms/designer?id=${id}`,
+            target: 'blank'
+        });
+        await this.navigation.execute(context);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOpenFormTemplateDesignerAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOpenFormTemplateDesignerAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOpenFormTemplateDesignerAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMDesignFormTemplateWorkflow = {
+    startStepId: 'open-design-designer',
+    steps: {
+        "open-design-designer": {
+            action: 'open-form-template-designer',
+        },
+    },
+};
+
+class AXPTemplateWidgetProviderImpl {
+    constructor() {
+        this.service = inject(AXMFormTemplateManagementTemplateEntityService);
+    }
+    async items(query) {
+        const result = ((await this.service.query(query)).items).map(c => ({
+            id: c.id,
+            title: c.title,
+            group: {
+                name: 'other',
+                order: 2,
+                title: "Saved"
+            },
+            description: c.description
+        }));
+        return result;
+    }
+    async get(id) {
+        const item = await this.service.getOne(id);
+        if (item) {
+            const document = JSON.parse(item.template);
+            return document?.children?.[0];
+        }
+        else {
+            throw Error("Invalid Id");
+        }
+    }
+}
+
+const routes = [
+    {
+        path: 'forms',
+        children: [
+            {
+                path: 'designer',
+                loadComponent: () => import('./acorex-modules-form-template-management-designer.page-NhIPhsRs.mjs').then((c) => c.AXMFormTemplateManagementModuleDesignerPage),
+            },
+            {
+                path: 'preview',
+                loadComponent: () => import('@acorex/platform/layout/designer').then((c) => c.AXPLayoutDesignerPreviewComponent),
+            },
+            {
+                path: 'viewer',
+                loadComponent: () => import('@acorex/platform/layout/designer').then((c) => c.AXPLayoutDesignerPreviewViewerComponent),
+            },
+        ],
+    },
+];
+class AXMFormTemplateManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, imports: [i1$1.RouterModule, AXPWidgetsModule,
+            AXMFormTemplateManagementCategoryEntityModule,
+            AXMFormTemplateManagementTemplateEntityModule, i2$1.AXPLayoutBuilderModule, i3.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, providers: [
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMFormTemplateManagementModuleEntityProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMFormTemplateManagementModuleMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXPDesignerConnector,
+                useClass: AXPDesignerConnectorImpl
+            },
+            {
+                provide: AXP_TEMPLATE_WIDGET_PROVIDER,
+                useClass: AXPTemplateWidgetProviderImpl,
+                multi: true,
+            }
+        ], imports: [RouterModule.forChild(routes),
+            AXPWidgetsModule,
+            AXMFormTemplateManagementCategoryEntityModule,
+            AXMFormTemplateManagementTemplateEntityModule,
+            AXPLayoutBuilderModule.forChild({
+                widgets: [
+                    AXPTemplateDesignerWidget
+                ]
+            }),
+            AXPWorkflowModule.forChild({
+                actions: {
+                    'open-form-template-designer': AXMOpenFormTemplateDesignerAction
+                },
+                workflows: {
+                    'create-form-template': AXMCreateFormTemplateWorkflow,
+                    'design-form-template': AXMDesignFormTemplateWorkflow
+                }
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFormTemplateManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        RouterModule.forChild(routes),
+                        AXPWidgetsModule,
+                        AXMFormTemplateManagementCategoryEntityModule,
+                        AXMFormTemplateManagementTemplateEntityModule,
+                        AXPLayoutBuilderModule.forChild({
+                            widgets: [
+                                AXPTemplateDesignerWidget
+                            ]
+                        }),
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                'open-form-template-designer': AXMOpenFormTemplateDesignerAction
+                            },
+                            workflows: {
+                                'create-form-template': AXMCreateFormTemplateWorkflow,
+                                'design-form-template': AXMDesignFormTemplateWorkflow
+                            }
+                        })
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMFormTemplateManagementModuleEntityProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMFormTemplateManagementModuleMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXPDesignerConnector,
+                            useClass: AXPDesignerConnectorImpl
+                        },
+                        {
+                            provide: AXP_TEMPLATE_WIDGET_PROVIDER,
+                            useClass: AXPTemplateWidgetProviderImpl,
+                            multi: true,
+                        }
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMFormTemplateManagementModule };
+//# sourceMappingURL=acorex-modules-form-template-management.mjs.map