@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/esm2022/tableview/api/tableview/helpers/tableview-input-builder.mjs

@@ -0,0 +1,162 @@
+import { createTableviewActions, getTableviewDefaultActions } from './tableview-default-actions';
+/**
+ * The `TableviewBuilder` class is used to build a tableview configuration.
+ * It allows you to set various options such as the descriptor, data provider,
+ * default actions, and custom actions for the tableview.
+ *
+ * @typeparam Model - The main model type.
+ * @typeparam Service - The API service type.
+ * @typeparam Descriptor - The descriptor type.
+ * @typeparam DataProvider - The data provider type.
+ * @typeparam Sorts - The sort type representing available sort keys.
+ * @typeparam Filters - The filter type representing available filter keys.
+ */
+export class TableviewInputBuilder {
+    constructor(_descriptor, _dataProvider, injector) {
+        this._descriptor = _descriptor;
+        this._dataProvider = _dataProvider;
+        this.injector = injector;
+        this.defaultActions = getTableviewDefaultActions().map(a => ({ type: a, descriptor: undefined }));
+        this._customActions = [];
+    }
+    prepareSetterParams() {
+        return { descriptor: this._descriptor, dataProvider: this._dataProvider, injector: this.injector };
+    }
+    /**
+     * Sets a descriptor instead of the default one.
+     *
+     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDescriptor(fn) {
+        this._descriptor = fn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Adjusts the descriptor using the provided adjust function.
+     *
+     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDescriptor(adjustFn) {
+        adjustFn(this._descriptor);
+        return this;
+    }
+    /**
+     * Sets the data provider for the TvBuilder instance
+     *
+     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * * @returns {this} - Returns the current instance of the builder.
+     */
+    withDataProvider(fn) {
+        this._dataProvider = fn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Adjusts the data provider using the provided adjust function.
+     *
+     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDataProvider(adjustFn) {
+        adjustFn(this._dataProvider);
+        return this;
+    }
+    /**
+     * Adjusts the data provider and/or descriptor using the provided adjust function.
+     *
+     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjust(adjustFn) {
+        adjustFn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Removes all the default tableview actions.
+     *
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withNoDefaultActions() {
+        this.defaultActions.forEach(a => (a.descriptor = null));
+        return this;
+    }
+    /**
+     * Adds the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActions(...types) {
+        types.forEach(type => {
+            const action = this.defaultActions.find(a => a.type === type);
+            if (action?.descriptor === null) {
+                action.descriptor = undefined;
+            }
+        });
+        return this;
+    }
+    /**
+     * Removes the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withoutDefaultActions(...types) {
+        types.forEach(type => {
+            const action = this.defaultActions.find(a => a.type === type);
+            if (action) {
+                action.descriptor = null;
+            }
+        });
+        return this;
+    }
+    /**
+     * Overrides the default action.
+     *
+     * @param {TableviewDefaultActionsEnum} type - The default actions to override.
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActionOverride(type, fn) {
+        const action = this.defaultActions.find(a => a.type === type);
+        if (action) {
+            action.descriptor = fn(this.prepareSetterParams()) ?? null;
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAction(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Builds and returns an instance of ITableview.
+     * DO NOT CALL this within tableview create callback function!
+     *
+     * @return {ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
+     */
+    build() {
+        return {
+            actions: createTableviewActions(this._descriptor, this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type), this.defaultActions
+                .filter(a => a.descriptor != null)
+                .reduce((acc, a) => ({
+                ...acc,
+                [a.type]: a.descriptor
+            }), {}), this.injector).concat(this._customActions),
+            dataProvider: this._dataProvider,
+            descriptor: this._descriptor
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-input-builder.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/tableview/helpers/tableview-input-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injector} from '@angular/core';\n\nimport {IDataProvider, Nullable} from '@mediusinc/mng-commons/core';\n\nimport {ActionDescriptorInst} from '../../action/descriptors/action.descriptor';\nimport {TableviewDescriptorInst} from '../descriptors/tableview.descriptor';\nimport {TableviewInput} from '../models/tableview-input.model';\nimport {TableviewDefaultActionsEnum, createTableviewActions, getTableviewDefaultActions} from './tableview-default-actions';\n\nexport type TvBuilderSetterParamsType<Descriptor, DataProvider> = {descriptor: Descriptor; dataProvider: DataProvider; injector: Injector};\nexport type TvBuilderActionSetterFnType<ActionModel, ActionService, Descriptor, DataProvider> = (\n    params: TvBuilderSetterParamsType<Descriptor, DataProvider>\n) => Nullable<ActionDescriptorInst<ActionModel, ActionService>>;\nexport type TvBuilderDescriptorSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Descriptor;\nexport type TvBuilderDataProviderSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => DataProvider;\n\ntype DefaultAction = {\n    type: TableviewDefaultActionsEnum;\n    descriptor: ActionDescriptorInst<any, any> | null | undefined;\n};\n\n/**\n * The `TableviewBuilder` class is used to build a tableview configuration.\n * It allows you to set various options such as the descriptor, data provider,\n * default actions, and custom actions for the tableview.\n *\n * @typeparam Model - The main model type.\n * @typeparam Service - The API service type.\n * @typeparam Descriptor - The descriptor type.\n * @typeparam DataProvider - The data provider type.\n * @typeparam Sorts - The sort type representing available sort keys.\n * @typeparam Filters - The filter type representing available filter keys.\n */\nexport class TableviewInputBuilder<\n    Model,\n    Service,\n    Descriptor extends TableviewDescriptorInst<Model, Sorts, Filters>,\n    DataProvider extends IDataProvider<Model, Service>,\n    Sorts = keyof Model,\n    Filters extends keyof any = keyof Model\n> {\n    private defaultActions: DefaultAction[] = getTableviewDefaultActions().map(a => ({type: a, descriptor: undefined}));\n    private readonly _customActions: ActionDescriptorInst<any>[] = [];\n\n    constructor(\n        private _descriptor: Descriptor,\n        private _dataProvider: DataProvider,\n        private readonly injector: Injector\n    ) {}\n\n    private prepareSetterParams(): TvBuilderSetterParamsType<Descriptor, DataProvider> {\n        return {descriptor: this._descriptor, dataProvider: this._dataProvider, injector: this.injector};\n    }\n\n    /**\n     * Sets a descriptor instead of the default one.\n     *\n     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDescriptor(fn: TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>): this {\n        this._descriptor = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the descriptor using the provided adjust function.\n     *\n     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDescriptor(adjustFn: (descriptor: Descriptor) => void): this {\n        adjustFn(this._descriptor);\n        return this;\n    }\n\n    /**\n     * Sets the data provider for the TvBuilder instance\n     *\n     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * * @returns {this} - Returns the current instance of the builder.\n     */\n    withDataProvider(fn: TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>): this {\n        this._dataProvider = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider using the provided adjust function.\n     *\n     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDataProvider(adjustFn: (dataProvider: DataProvider) => void): this {\n        adjustFn(this._dataProvider);\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider and/or descriptor using the provided adjust function.\n     *\n     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjust(adjustFn: (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void): this {\n        adjustFn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Removes all the default tableview actions.\n     *\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withNoDefaultActions(): this {\n        this.defaultActions.forEach(a => (a.descriptor = null));\n        return this;\n    }\n\n    /**\n     * Adds the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action?.descriptor === null) {\n                action.descriptor = undefined;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Removes the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withoutDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action) {\n                action.descriptor = null;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Overrides the default action.\n     *\n     * @param {TableviewDefaultActionsEnum} type - The default actions to override.\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActionOverride<ActionService = Service>(type: TableviewDefaultActionsEnum, fn: TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>): this {\n        const action = this.defaultActions.find(a => a.type === type);\n        if (action) {\n            action.descriptor = fn(this.prepareSetterParams()) ?? null;\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action.\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAction<ActionModel = Model, ActionService = Service>(fn: TvBuilderActionSetterFnType<ActionModel, ActionService, Descriptor, DataProvider>): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * Builds and returns an instance of ITableview.\n     * DO NOT CALL this within tableview create callback function!\n     *\n     * @return {ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.\n     */\n    build() {\n        return <TableviewInput<Model, Service, Sorts, Filters, Descriptor, DataProvider>>{\n            actions: createTableviewActions(\n                this._descriptor as TableviewDescriptorInst<any, any, any>,\n                this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type),\n                this.defaultActions\n                    .filter(a => a.descriptor != null)\n                    .reduce(\n                        (acc, a) => ({\n                            ...acc,\n                            [a.type]: a.descriptor!\n                        }),\n                        <Record<number, ActionDescriptorInst<any>>>{}\n                    ),\n                this.injector\n            ).concat(this._customActions),\n            dataProvider: this._dataProvider,\n            descriptor: this._descriptor\n        };\n    }\n}\n"]}

package/esm2022/tableview/api/tableview/models/class-tableview-attribute.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3MtdGFibGV2aWV3LWF0dHJpYnV0ZS5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3RhYmxldmlldy9hcGkvc3JjL3RhYmxldmlldy9tb2RlbHMvY2xhc3MtdGFibGV2aWV3LWF0dHJpYnV0ZS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtUYWJsZUNsYXNzQXR0cmlidXRlRGVmfSBmcm9tICdAbWVkaXVzaW5jL21uZy1jb21tb25zL3RhYmxlL2FwaSc7XG5cbmltcG9ydCB7RWRpdG9yQ2xhc3NBdHRyaWJ1dGVEZWZ9IGZyb20gJy4uLy4uL2VkaXRvci9tb2RlbHMvY2xhc3MtdGFibGV2aWV3LWF0dHJpYnV0ZS5tb2RlbCc7XG5cbmV4cG9ydCB0eXBlIFRhYmxldmlld0NsYXNzQXR0cmlidXRlRGVmID0gRWRpdG9yQ2xhc3NBdHRyaWJ1dGVEZWYgJiBUYWJsZUNsYXNzQXR0cmlidXRlRGVmO1xuIl19

package/esm2022/tableview/api/tableview/models/tableview-input.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGV2aWV3LWlucHV0Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vdGFibGV2aWV3L2FwaS9zcmMvdGFibGV2aWV3L21vZGVscy90YWJsZXZpZXctaW5wdXQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QWN0aW9uRGVzY3JpcHRvckluc3R9IGZyb20gJy4uLy4uL2FjdGlvbi9kZXNjcmlwdG9ycy9hY3Rpb24uZGVzY3JpcHRvcic7XG5pbXBvcnQge0lUYWJsZXZpZXdEYXRhUHJvdmlkZXJ9IGZyb20gJy4uL2RhdGEtcHJvdmlkZXJzL3RhYmxldmlldy5kYXRhLXByb3ZpZGVyJztcbmltcG9ydCB7VGFibGV2aWV3RGVzY3JpcHRvckluc3R9IGZyb20gJy4uL2Rlc2NyaXB0b3JzL3RhYmxldmlldy5kZXNjcmlwdG9yJztcblxuZXhwb3J0IGludGVyZmFjZSBUYWJsZXZpZXdJbnB1dDxcbiAgICBNb2RlbCxcbiAgICBTZXJ2aWNlLFxuICAgIFNvcnRzID0ga2V5b2YgTW9kZWwsXG4gICAgRmlsdGVycyBleHRlbmRzIGtleW9mIGFueSA9IGtleW9mIE1vZGVsLFxuICAgIERlc2NyaXB0b3IgPSBUYWJsZXZpZXdEZXNjcmlwdG9ySW5zdDxNb2RlbCwgU29ydHMsIEZpbHRlcnM+LFxuICAgIERhdGFQcm92aWRlciA9IElUYWJsZXZpZXdEYXRhUHJvdmlkZXI8TW9kZWwsIFNlcnZpY2UsIFNvcnRzLCBGaWx0ZXJzPlxuPiB7XG4gICAgZGVzY3JpcHRvcjogRGVzY3JpcHRvcjtcbiAgICBkYXRhUHJvdmlkZXI6IERhdGFQcm92aWRlcjtcbiAgICBhY3Rpb25zOiBBY3Rpb25EZXNjcmlwdG9ySW5zdDxNb2RlbD5bXTtcbn1cbiJdfQ==

package/esm2022/tableview/api/tableview/models/tableview-route.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGV2aWV3LXJvdXRlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vdGFibGV2aWV3L2FwaS9zcmMvdGFibGV2aWV3L21vZGVscy90YWJsZXZpZXctcm91dGUubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QVBlcm1pc3Npb25zLCBDb21tb25zUm91dGVEYXRhfSBmcm9tICdAbWVkaXVzaW5jL21uZy1jb21tb25zL2NvcmUnO1xuXG5pbXBvcnQge0FjdGlvbkRlc2NyaXB0b3JJbnN0fSBmcm9tICcuLi8uLi9hY3Rpb24vZGVzY3JpcHRvcnMvYWN0aW9uLmRlc2NyaXB0b3InO1xuaW1wb3J0IHtJVGFibGV2aWV3RGF0YVByb3ZpZGVyfSBmcm9tICcuLi9kYXRhLXByb3ZpZGVycy90YWJsZXZpZXcuZGF0YS1wcm92aWRlcic7XG5pbXBvcnQge1RhYmxldmlld0Rlc2NyaXB0b3JJbnN0fSBmcm9tICcuLi9kZXNjcmlwdG9ycy90YWJsZXZpZXcuZGVzY3JpcHRvcic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGFibGV2aWV3Um91dGVEYXRhIGV4dGVuZHMgQ29tbW9uc1JvdXRlRGF0YSB7XG4gICAgdGFibGV2aWV3Pzoge1xuICAgICAgICBkZXNjcmlwdG9yOiBUYWJsZXZpZXdEZXNjcmlwdG9ySW5zdDxhbnksIGFueSwgYW55PjtcbiAgICAgICAgZGF0YVByb3ZpZGVyOiBJVGFibGV2aWV3RGF0YVByb3ZpZGVyO1xuICAgICAgICBhY3Rpb25zPzogQXJyYXk8QWN0aW9uRGVzY3JpcHRvckluc3Q8YW55Pj47XG4gICAgfTtcbiAgICB0YWJsZXZpZXdQZXJtaXNzaW9ucz86IHtcbiAgICAgICAgW2tleTogc3RyaW5nXTogQVBlcm1pc3Npb25zO1xuICAgIH07XG4gICAgLy8gdGFibGV2aWV3IGFjdGlvbnMgZGVmaW5lZCB2aWEgcm91dGUgYnVpbGRlclxuICAgIHRhYmxldmlld0FjdGlvbnM/OiB7XG4gICAgICAgIGhhc0FkZD86IGJvb2xlYW47XG4gICAgICAgIGhhc0VkaXQ/OiBib29sZWFuO1xuICAgICAgICBoYXNEZXRhaWxzPzogYm9vbGVhbjtcbiAgICAgICAgaGFzRGVsZXRlPzogYm9vbGVhbjtcbiAgICB9O1xufVxuIl19

package/esm2022/tableview/editor/components/editor/form-editor.component.mjs

@@ -0,0 +1,285 @@
+import { AsyncPipe } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChildren, ElementRef, EventEmitter, Input, Output, QueryList, ViewChild, inject } from '@angular/core';
+import { FormArray, FormGroup, ReactiveFormsModule } from '@angular/forms';
+import { FormlyModule } from '@ngx-formly/core';
+import { TranslateService } from '@ngx-translate/core';
+import { ButtonModule } from 'primeng/button';
+import { MessagesModule } from 'primeng/messages';
+import { Observable, debounceTime, distinctUntilChanged, of } from 'rxjs';
+import { CommonsService, LoggerService, ObjectUtil, TemplateDirective } from '@mediusinc/mng-commons/core';
+import { EditorDescriptorInst, FormEventTypeEnum, FormFieldEventComponentSubtype, TableviewEditorTypeEnum } from '@mediusinc/mng-commons/tableview/api';
+import { ViewContainer } from '../../../action/services/view-container.service';
+import { getFormEditorInfoMessage, getFormEditorWarningMessage } from '../../helpers/notification';
+import { EditorFormlyUtil } from '../../utils/editor-formly.util';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-formly/core";
+import * as i2 from "@angular/forms";
+import * as i3 from "primeng/messages";
+import * as i4 from "primeng/button";
+export class FormEditorComponent {
+    constructor() {
+        this.translateService = inject(TranslateService);
+        this.commons = inject(CommonsService);
+        this.logger = inject(LoggerService).create('FormEditorComponent');
+        this.viewContainer = inject(ViewContainer, { optional: true });
+        this.submitLoading = false;
+        // extra features input
+        this.isFormDisabled = false;
+        // event outputs
+        this.formSubmitEventEmitter = new EventEmitter();
+        this.form = new FormGroup({});
+        this.formOptions = {
+            formState: {
+                add: false,
+                edit: false,
+                disabled: false
+            }
+        };
+        this.formModel = {};
+        this.formMessages = [];
+        this.subscriptions = [];
+    }
+    ngOnInit() {
+        this.setInitialFormState();
+        this.resetFormModel(this.item);
+        this.submitLoading$ = this.submitLoading instanceof Observable ? this.submitLoading : of(this.submitLoading);
+        if (this.descriptor) {
+            // init fields for formly
+            this.formFields = EditorFormlyUtil.createFormlyConfigFromDescriptor(this.descriptor, this);
+            this.updateFormState();
+            // let the user know, that adding new value in table view with localizations is only supported in the default language
+            if (this.descriptor.isLocalized &&
+                (this.descriptor.tableviewEditorType === TableviewEditorTypeEnum.Add || this.descriptor.tableviewEditorType === TableviewEditorTypeEnum.Edit)) {
+                this.formMessages.push(getFormEditorInfoMessage(this.translateService, 'mngEditor.localizations.addInDefaultLanguageTitle', 'mngEditor.localizations.addInDefaultLanguageDescription', { defaultLanguage: this.commons.defaultDataLanguage }));
+            }
+        }
+        // emit lifecycle event
+        this.descriptor?.nextEvent(FormEventTypeEnum.ComponentLifecycle, FormEditorComponent, this, {
+            eventSubtype: FormFieldEventComponentSubtype.ON_INIT
+        });
+        this.subscriptions.push(this.form.valueChanges.pipe(debounceTime(250), distinctUntilChanged()).subscribe(v => {
+            this.descriptor?.nextEvent(FormEventTypeEnum.ValueChange, FormEditorComponent, this, {
+                value: v,
+                formValue: () => this.getFormValue()
+            });
+        }));
+    }
+    ngOnChanges(changes) {
+        if (changes['isFormDisabled'] && !changes['isFormDisabled'].firstChange) {
+            this.updateFormState();
+        }
+        if (changes['item'] && !changes['item'].firstChange) {
+            this.resetFormModel(this.item);
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(s => s.unsubscribe());
+        // emit lifecycle event
+        this.descriptor?.nextEvent(FormEventTypeEnum.ComponentLifecycle, FormEditorComponent, this, {
+            eventSubtype: FormFieldEventComponentSubtype.ON_DESTROY
+        });
+        // complete emitting events
+        this.descriptor?.completeEvents();
+    }
+    submit() {
+        this.submitButtonElementRef?.nativeElement.click();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onSubmit(event) {
+        this.formOptions.formState.submittedOn = Date.now();
+        this.formMessages = [];
+        const formSubmitItem = this.getFormValue();
+        if (this.form.valid) {
+            this.formSubmitEventEmitter.next({
+                success: true,
+                formItem: formSubmitItem
+            });
+            this.descriptor?.nextEvent(FormEventTypeEnum.Submit, FormEditorComponent, this, {
+                submitValid: true,
+                submitValue: formSubmitItem
+            });
+        }
+        else {
+            // find and mark invalid tabs
+            if (this.formFields[0].type === 'tabs' && this.formFields[0].fieldGroup) {
+                for (const tab of this.formFields[0].fieldGroup) {
+                    const isInvalid = this.isAnyFieldInvalid(tab.fieldGroup);
+                    this.formOptions.formState['tab_' + (tab.id ? tab.id : tab.props.props.label) + '_invalid'] = isInvalid;
+                }
+            }
+            const event = { success: false, formItem: formSubmitItem };
+            event.success = false;
+            this.formMessages.push(getFormEditorWarningMessage(this.translateService, 'mngEditor.invalidFormToastTitle', 'mngEditor.invalidFormToastMessage'));
+            this.formSubmitEventEmitter.next(event);
+            this.descriptor?.nextEvent(FormEventTypeEnum.Submit, FormEditorComponent, this, {
+                submitValid: false,
+                submitValue: formSubmitItem
+            });
+        }
+    }
+    getFormValue() {
+        const formValue = ObjectUtil.deepCopy(this.form.getRawValue(), { mapGettersToProperties: true });
+        this.descriptor?.fields.forEach(field => {
+            if (field && field.setter) {
+                const splitPath = field.property.split('.');
+                let fieldValue = formValue;
+                for (let i = 0; i < splitPath.length - 1; i++) {
+                    const currentSubPath = splitPath[i];
+                    if (typeof fieldValue[currentSubPath] !== 'object') {
+                        fieldValue[currentSubPath] = {};
+                    }
+                    fieldValue = fieldValue[currentSubPath];
+                }
+                fieldValue = fieldValue[splitPath[splitPath.length - 1]];
+                field.setter(formValue, fieldValue);
+            }
+        });
+        return formValue;
+    }
+    resetFormModel(item, markAsPristine = true) {
+        if (typeof item !== 'undefined') {
+            this.originalItemPrototype = Object.getPrototypeOf(item);
+        }
+        const formModel = ObjectUtil.deepCopy(item, { mapGettersToProperties: true }) ?? {};
+        this.descriptor?.fields.forEach(field => {
+            if (field.getter && item) {
+                const splitPath = field.property.split('.');
+                let currentObject = formModel;
+                for (let i = 0; i < splitPath.length; i++) {
+                    const currentSubPath = splitPath[i];
+                    if (i === splitPath.length - 1) {
+                        currentObject[currentSubPath] = field.getter(item?.[field.property], item);
+                    }
+                    else {
+                        if (typeof currentObject[currentSubPath] !== 'object') {
+                            currentObject[currentSubPath] = {};
+                        }
+                        currentObject = currentObject[currentSubPath];
+                    }
+                }
+            }
+        });
+        if (typeof this.formOptions.resetModel === 'function') {
+            // could not be initiated yet
+            this.formOptions.resetModel(this.formModel);
+        }
+        this.formModel = formModel;
+        if (markAsPristine) {
+            this.form.markAsPristine();
+        }
+    }
+    getFormField(key) {
+        return this.findFormField(this.form, key.split('.'));
+    }
+    setFormFieldValue(key, value) {
+        const control = this.getFormField(key);
+        if (control) {
+            control.setValue(value);
+            return true;
+        }
+        else {
+            this.logger.warn(`Value was not set, because field ${key} was not found.`);
+            return false;
+        }
+    }
+    patchFormFieldValue(key, value) {
+        const control = this.getFormField(key);
+        if (control) {
+            control.patchValue(value);
+            return true;
+        }
+        else {
+            this.logger.warn(`Value was not set, because field ${key} was not found.`);
+            return false;
+        }
+    }
+    resetFormFieldValue(key, value) {
+        const control = this.getFormField(key);
+        if (control) {
+            control.reset(value);
+            return true;
+        }
+        else {
+            this.logger.warn(`Value was not set, because field ${key} was not found.`);
+            return false;
+        }
+    }
+    findFormField(control, keyPath) {
+        if (keyPath.length === 0) {
+            return control;
+        }
+        if (keyPath.length === 1) {
+            return control.get(keyPath[0]);
+        }
+        let nextControl = null;
+        if (control instanceof FormGroup) {
+            nextControl = control.get(keyPath[0]);
+        }
+        else if (control instanceof FormArray) {
+            const idx = +keyPath[0];
+            if (!isNaN(idx)) {
+                nextControl = control.at(idx);
+            }
+        }
+        if (!control) {
+            return null;
+        }
+        return this.findFormField(nextControl, keyPath.slice(1));
+    }
+    isAnyFieldInvalid(fields = []) {
+        for (const field of fields) {
+            let fieldInvalid = false;
+            if (Array.isArray(field.fieldGroup)) {
+                fieldInvalid = this.isAnyFieldInvalid(field.fieldGroup);
+            }
+            else if (typeof field.type !== 'undefined') {
+                fieldInvalid = !field.formControl?.valid;
+            }
+            if (fieldInvalid) {
+                return true;
+            }
+        }
+        return false;
+    }
+    updateFormState() {
+        const isDisabled = this.isFormDisabled || this.descriptor?.disabled === true || this.descriptor?.tableviewEditorType === TableviewEditorTypeEnum.Details;
+        this.formOptions.formState.disabled = isDisabled;
+    }
+    /**
+     * @private Sets form state based on editor descriptor type.
+     * Possible options are: disabled, add or edit.
+     */
+    setInitialFormState() {
+        if (this.descriptor?.tableviewEditorType === TableviewEditorTypeEnum.Add) {
+            this.formOptions.formState.add = true;
+        }
+        else if (this.descriptor?.tableviewEditorType === TableviewEditorTypeEnum.Edit) {
+            this.formOptions.formState.edit = true;
+        }
+        this.updateFormState();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: FormEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: FormEditorComponent, isStandalone: true, selector: "mng-form-editor", inputs: { descriptor: "descriptor", submitLoading: "submitLoading", item: "item", isFormDisabled: "isFormDisabled" }, outputs: { formSubmitEventEmitter: "formSubmit" }, queries: [{ propertyName: "templates", predicate: TemplateDirective }], viewQueries: [{ propertyName: "submitButtonElementRef", first: true, predicate: ["submitButton"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<form [formGroup]=\"form\" (ngSubmit)=\"onSubmit($event)\">\n    <formly-form [form]=\"form\" [fields]=\"formFields\" [options]=\"formOptions\" [model]=\"formModel\"></formly-form>\n    <button\n        #submitButton\n        pButton\n        type=\"submit\"\n        class=\"hidden\"\n        [disabled]=\"form.disabled\"\n        [loading]=\"(submitLoading$ | async) ?? false\"\n        loadingIcon=\"pi pi-spin pi-spinner\"></button>\n</form>\n<p-messages [value]=\"formMessages\" [enableService]=\"false\"></p-messages>\n", dependencies: [{ kind: "ngmodule", type: FormlyModule }, { kind: "component", type: i1.FormlyForm, selector: "formly-form", inputs: ["form", "model", "fields", "options"], outputs: ["modelChange"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: MessagesModule }, { kind: "component", type: i3.Messages, selector: "p-messages", inputs: ["value", "closable", "style", "styleClass", "enableService", "key", "escape", "severity", "showTransitionOptions", "hideTransitionOptions"], outputs: ["valueChange", "onClose"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i4.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: FormEditorComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'mng-form-editor', imports: [FormlyModule, ReactiveFormsModule, MessagesModule, AsyncPipe, ButtonModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<form [formGroup]=\"form\" (ngSubmit)=\"onSubmit($event)\">\n    <formly-form [form]=\"form\" [fields]=\"formFields\" [options]=\"formOptions\" [model]=\"formModel\"></formly-form>\n    <button\n        #submitButton\n        pButton\n        type=\"submit\"\n        class=\"hidden\"\n        [disabled]=\"form.disabled\"\n        [loading]=\"(submitLoading$ | async) ?? false\"\n        loadingIcon=\"pi pi-spin pi-spinner\"></button>\n</form>\n<p-messages [value]=\"formMessages\" [enableService]=\"false\"></p-messages>\n" }]
+        }], propDecorators: { descriptor: [{
+                type: Input
+            }], submitLoading: [{
+                type: Input
+            }], item: [{
+                type: Input
+            }], isFormDisabled: [{
+                type: Input
+            }], formSubmitEventEmitter: [{
+                type: Output,
+                args: ['formSubmit']
+            }], templates: [{
+                type: ContentChildren,
+                args: [TemplateDirective]
+            }], submitButtonElementRef: [{
+                type: ViewChild,
+                args: ['submitButton']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-editor.component.js","sourceRoot":"","sources":["../../../../../../tableview/src/editor/components/editor/form-editor.component.ts","../../../../../../tableview/src/editor/components/editor/form-editor.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EACH,uBAAuB,EACvB,SAAS,EACT,eAAe,EACf,UAAU,EACV,YAAY,EACZ,KAAK,EAIL,MAAM,EACN,SAAS,EAGT,SAAS,EACT,MAAM,EACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAkB,SAAS,EAAE,SAAS,EAAE,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAE1F,OAAO,EAAuC,YAAY,EAAC,MAAM,kBAAkB,CAAC;AACpF,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAC,UAAU,EAAgB,YAAY,EAAE,oBAAoB,EAAE,EAAE,EAAC,MAAM,MAAM,CAAC;AAEtF,OAAO,EAAC,cAAc,EAAE,aAAa,EAAE,UAAU,EAAE,iBAAiB,EAAC,MAAM,6BAA6B,CAAC;AACzG,OAAO,EAEH,oBAAoB,EAEpB,iBAAiB,EACjB,8BAA8B,EAE9B,uBAAuB,EAC1B,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAC,aAAa,EAAC,MAAM,iDAAiD,CAAC;AAC9E,OAAO,EAAC,wBAAwB,EAAE,2BAA2B,EAAC,MAAM,4BAA4B,CAAC;AACjG,OAAO,EAAC,gBAAgB,EAAC,MAAM,gCAAgC,CAAC;;;;;;AAShE,MAAM,OAAO,mBAAmB;IAPhC;QAQqB,qBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAC5C,YAAO,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QACjC,WAAM,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;QACtE,kBAAa,GAAG,MAAM,CAAC,aAAa,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QAIhD,kBAAa,GAAkC,KAAK,CAAC;QAKrE,uBAAuB;QACP,mBAAc,GAAG,KAAK,CAAC;QAEvC,gBAAgB;QACa,2BAAsB,GAAG,IAAI,YAAY,EAA+B,CAAC;QAM/F,SAAI,GAAc,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC;QACpC,gBAAW,GAAsB;YACpC,SAAS,EAAE;gBACP,GAAG,EAAE,KAAK;gBACV,IAAI,EAAE,KAAK;gBACX,QAAQ,EAAE,KAAK;aAClB;SACJ,CAAC;QAEK,cAAS,GAAQ,EAAE,CAAC;QACpB,iBAAY,GAAc,EAAE,CAAC;QAI5B,kBAAa,GAAmB,EAAE,CAAC;KA6P9C;IA3PU,QAAQ;QACX,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,YAAY,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAE7G,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,yBAAyB;YACzB,IAAI,CAAC,UAAU,GAAG,gBAAgB,CAAC,gCAAgC,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YAC3F,IAAI,CAAC,eAAe,EAAE,CAAC;YAEvB,sHAAsH;YACtH,IACI,IAAI,CAAC,UAAU,CAAC,WAAW;gBAC3B,CAAC,IAAI,CAAC,UAAU,CAAC,mBAAmB,KAAK,uBAAuB,CAAC,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,mBAAmB,KAAK,uBAAuB,CAAC,IAAI,CAAC,EAC/I;gBACE,IAAI,CAAC,YAAY,CAAC,IAAI,CAClB,wBAAwB,CACpB,IAAI,CAAC,gBAAgB,EACrB,mDAAmD,EACnD,yDAAyD,EACzD,EAAC,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAC,CACtD,CACJ,CAAC;aACL;SACJ;QAED,uBAAuB;QACvB,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,mBAAmB,EAAE,IAAI,EAAE;YACxF,YAAY,EAAE,8BAA8B,CAAC,OAAO;SACvD,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,CAAC,IAAI,CACnB,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,oBAAoB,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;YACjF,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,IAAI,EAAE;gBACjF,KAAK,EAAE,CAAC;gBACR,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE;aACvC,CAAC,CAAC;QACP,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAED,WAAW,CAAC,OAAsB;QAC9B,IAAI,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,WAAW,EAAE;YACrE,IAAI,CAAC,eAAe,EAAE,CAAC;SAC1B;QACD,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE;YACjD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAClC;IACL,CAAC;IAEM,WAAW;QACd,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QAEjD,uBAAuB;QACvB,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,mBAAmB,EAAE,IAAI,EAAE;YACxF,YAAY,EAAE,8BAA8B,CAAC,UAAU;SAC1D,CAAC,CAAC;QACH,2BAA2B;QAC3B,IAAI,CAAC,UAAU,EAAE,cAAc,EAAE,CAAC;IACtC,CAAC;IAEM,MAAM;QACT,IAAI,CAAC,sBAAsB,EAAE,aAAa,CAAC,KAAK,EAAE,CAAC;IACvD,CAAC;IAED,6DAA6D;IACtD,QAAQ,CAAC,KAAY;QACxB,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpD,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QAEvB,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QAC3C,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACjB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC;gBAC7B,OAAO,EAAE,IAAI;gBACb,QAAQ,EAAE,cAAc;aAC3B,CAAC,CAAC;YACH,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE;gBAC5E,WAAW,EAAE,IAAI;gBACjB,WAAW,EAAE,cAAc;aAC9B,CAAC,CAAC;SACN;aAAM;YACH,6BAA6B;YAC7B,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE;gBACrE,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE;oBAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;oBACzD,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAE,GAAG,CAAC,KAAkC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,GAAG,SAAS,CAAC;iBACzI;aACJ;YACD,MAAM,KAAK,GAAgC,EAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAC,CAAC;YACtF,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,gBAAgB,EAAE,iCAAiC,EAAE,mCAAmC,CAAC,CAAC,CAAC;YAEnJ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxC,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE;gBAC5E,WAAW,EAAE,KAAK;gBAClB,WAAW,EAAE,cAAc;aAC9B,CAAC,CAAC;SACN;IACL,CAAC;IAEM,YAAY;QACf,MAAM,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,EAAC,sBAAsB,EAAE,IAAI,EAAC,CAAC,CAAC;QAE/F,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACpC,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE;gBACvB,MAAM,SAAS,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC5C,IAAI,UAAU,GAAG,SAAS,CAAC;gBAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;oBAC3C,MAAM,cAAc,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;oBACpC,IAAI,OAAO,UAAU,CAAC,cAAc,CAAC,KAAK,QAAQ,EAAE;wBAChD,UAAU,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC;qBACnC;oBAED,UAAU,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;iBAC3C;gBAED,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;gBACzD,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;aACvC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACrB,CAAC;IAEM,cAAc,CAAC,IAAW,EAAE,cAAc,GAAG,IAAI;QACpD,IAAI,OAAO,IAAI,KAAK,WAAW,EAAE;YAC7B,IAAI,CAAC,qBAAqB,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;SAC5D;QAED,MAAM,SAAS,GAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAC,sBAAsB,EAAE,IAAI,EAAC,CAAyB,IAAI,EAAE,CAAC;QAE3G,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACpC,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,EAAE;gBACtB,MAAM,SAAS,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC5C,IAAI,aAAa,GAAG,SAAS,CAAC;gBAE9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACvC,MAAM,cAAc,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;oBACpC,IAAI,CAAC,KAAK,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;wBAC5B,aAAa,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,QAAwB,CAAC,EAAE,IAAI,CAAC,CAAC;qBAC9F;yBAAM;wBACH,IAAI,OAAO,aAAa,CAAC,cAAc,CAAC,KAAK,QAAQ,EAAE;4BACnD,aAAa,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC;yBACtC;wBAED,aAAa,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;qBACjD;iBACJ;aACJ;QACL,CAAC,CAAC,CAAC;QACH,IAAI,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,KAAK,UAAU,EAAE;YACnD,6BAA6B;YAC7B,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAC/C;QACD,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,cAAc,EAAE;YAChB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;SAC9B;IACL,CAAC;IAEM,YAAY,CAAC,GAAW;QAC3B,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IACzD,CAAC;IAEM,iBAAiB,CAAC,GAAW,EAAE,KAAU;QAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,OAAO,EAAE;YACT,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACxB,OAAO,IAAI,CAAC;SACf;aAAM;YACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,oCAAoC,GAAG,iBAAiB,CAAC,CAAC;YAC3E,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAEM,mBAAmB,CAAC,GAAW,EAAE,KAAU;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,OAAO,EAAE;YACT,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YAC1B,OAAO,IAAI,CAAC;SACf;aAAM;YACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,oCAAoC,GAAG,iBAAiB,CAAC,CAAC;YAC3E,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAEM,mBAAmB,CAAC,GAAW,EAAE,KAAW;QAC/C,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,OAAO,EAAE;YACT,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrB,OAAO,IAAI,CAAC;SACf;aAAM;YACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,oCAAoC,GAAG,iBAAiB,CAAC,CAAC;YAC3E,OAAO,KAAK,CAAC;SAChB;IACL,CAAC;IAEO,aAAa,CAAC,OAAwB,EAAE,OAAiB;QAC7D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,OAAO,OAAO,CAAC;SAClB;QACD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,OAAO,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;SAClC;QACD,IAAI,WAAW,GAA2B,IAAI,CAAC;QAC/C,IAAI,OAAO,YAAY,SAAS,EAAE;YAC9B,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;SACzC;aAAM,IAAI,OAAO,YAAY,SAAS,EAAE;YACrC,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;gBACb,WAAW,GAAG,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;aACjC;SACJ;QAED,IAAI,CAAC,OAAO,EAAE;YACV,OAAO,IAAI,CAAC;SACf;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,WAAY,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAEO,iBAAiB,CAAC,SAA8B,EAAE;QACtD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YACxB,IAAI,YAAY,GAAG,KAAK,CAAC;YACzB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;gBACjC,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;aAC3D;iBAAM,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,WAAW,EAAE;gBAC1C,YAAY,GAAG,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC;aAC5C;YACD,IAAI,YAAY,EAAE;gBACd,OAAO,IAAI,CAAC;aACf;SACJ;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAEO,eAAe;QACnB,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,UAAU,EAAE,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,mBAAmB,KAAK,uBAAuB,CAAC,OAAO,CAAC;QACzJ,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,QAAQ,GAAG,UAAU,CAAC;IACrD,CAAC;IAED;;;OAGG;IACK,mBAAmB;QACvB,IAAI,IAAI,CAAC,UAAU,EAAE,mBAAmB,KAAK,uBAAuB,CAAC,GAAG,EAAE;YACtE,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,GAAG,IAAI,CAAC;SACzC;aAAM,IAAI,IAAI,CAAC,UAAU,EAAE,mBAAmB,KAAK,uBAAuB,CAAC,IAAI,EAAE;YAC9E,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC;SAC1C;QACD,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;8GAjSQ,mBAAmB;kGAAnB,mBAAmB,8QAoBX,iBAAiB,0KCrEtC,+gBAYA,2CDkCc,YAAY,6KAAE,mBAAmB,obAAE,cAAc,uRAAE,SAAS,6CAAE,YAAY;;2FAG3E,mBAAmB;kBAP/B,SAAS;iCACM,IAAI,YACN,iBAAiB,WAElB,CAAC,YAAY,EAAE,mBAAmB,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,CAAC,mBACpE,uBAAuB,CAAC,MAAM;8BAS/B,UAAU;sBAAzB,KAAK;gBACU,aAAa;sBAA5B,KAAK;gBAGU,IAAI;sBAAnB,KAAK;gBAGU,cAAc;sBAA7B,KAAK;gBAGuB,sBAAsB;sBAAlD,MAAM;uBAAC,YAAY;gBAGuB,SAAS;sBAAnD,eAAe;uBAAC,iBAAiB;gBACA,sBAAsB;sBAAvD,SAAS;uBAAC,cAAc","sourcesContent":["import {AsyncPipe} from '@angular/common';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    ContentChildren,\n    ElementRef,\n    EventEmitter,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    QueryList,\n    SimpleChanges,\n    Type,\n    ViewChild,\n    inject\n} from '@angular/core';\nimport {AbstractControl, FormArray, FormGroup, ReactiveFormsModule} from '@angular/forms';\n\nimport {FormlyFieldConfig, FormlyFormOptions, FormlyModule} from '@ngx-formly/core';\nimport {TranslateService} from '@ngx-translate/core';\nimport {Message} from 'primeng/api';\nimport {ButtonModule} from 'primeng/button';\nimport {MessagesModule} from 'primeng/messages';\nimport {Observable, Subscription, debounceTime, distinctUntilChanged, of} from 'rxjs';\n\nimport {CommonsService, LoggerService, ObjectUtil, TemplateDirective} from '@mediusinc/mng-commons/core';\nimport {\n    CommonsFormlyFieldConfig,\n    EditorDescriptorInst,\n    FormEditorSubmitEvent,\n    FormEventTypeEnum,\n    FormFieldEventComponentSubtype,\n    IFormEditorComponent,\n    TableviewEditorTypeEnum\n} from '@mediusinc/mng-commons/tableview/api';\n\nimport {ViewContainer} from '../../../action/services/view-container.service';\nimport {getFormEditorInfoMessage, getFormEditorWarningMessage} from '../../helpers/notification';\nimport {EditorFormlyUtil} from '../../utils/editor-formly.util';\n\n@Component({\n    standalone: true,\n    selector: 'mng-form-editor',\n    templateUrl: './form-editor.component.html',\n    imports: [FormlyModule, ReactiveFormsModule, MessagesModule, AsyncPipe, ButtonModule],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FormEditorComponent<Item = any> implements IFormEditorComponent<Item>, OnInit, OnChanges, OnDestroy {\n    private readonly translateService = inject(TranslateService);\n    private readonly commons = inject(CommonsService);\n    private readonly logger = inject(LoggerService).create('FormEditorComponent');\n    private viewContainer = inject(ViewContainer, {optional: true});\n\n    // metadata and editor mode input\n    @Input() public descriptor?: EditorDescriptorInst<Item>;\n    @Input() public submitLoading: Observable<boolean> | boolean = false;\n\n    // data source inputs;\n    @Input() public item?: Item;\n\n    // extra features input\n    @Input() public isFormDisabled = false;\n\n    // event outputs\n    @Output('formSubmit') public formSubmitEventEmitter = new EventEmitter<FormEditorSubmitEvent<Item>>();\n\n    // content and view queries\n    @ContentChildren(TemplateDirective) public templates!: QueryList<TemplateDirective>;\n    @ViewChild('submitButton') public submitButtonElementRef?: ElementRef;\n\n    public form: FormGroup = new FormGroup({});\n    public formOptions: FormlyFormOptions = {\n        formState: {\n            add: false,\n            edit: false,\n            disabled: false\n        }\n    };\n    public formFields!: FormlyFieldConfig[];\n    public formModel: any = {};\n    public formMessages: Message[] = [];\n    public submitLoading$!: Observable<boolean>;\n    private originalItemPrototype?: Type<Item>;\n\n    private subscriptions: Subscription[] = [];\n\n    public ngOnInit() {\n        this.setInitialFormState();\n        this.resetFormModel(this.item);\n        this.submitLoading$ = this.submitLoading instanceof Observable ? this.submitLoading : of(this.submitLoading);\n\n        if (this.descriptor) {\n            // init fields for formly\n            this.formFields = EditorFormlyUtil.createFormlyConfigFromDescriptor(this.descriptor, this);\n            this.updateFormState();\n\n            // let the user know, that adding new value in table view with localizations is only supported in the default language\n            if (\n                this.descriptor.isLocalized &&\n                (this.descriptor.tableviewEditorType === TableviewEditorTypeEnum.Add || this.descriptor.tableviewEditorType === TableviewEditorTypeEnum.Edit)\n            ) {\n                this.formMessages.push(\n                    getFormEditorInfoMessage(\n                        this.translateService,\n                        'mngEditor.localizations.addInDefaultLanguageTitle',\n                        'mngEditor.localizations.addInDefaultLanguageDescription',\n                        {defaultLanguage: this.commons.defaultDataLanguage}\n                    )\n                );\n            }\n        }\n\n        // emit lifecycle event\n        this.descriptor?.nextEvent(FormEventTypeEnum.ComponentLifecycle, FormEditorComponent, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_INIT\n        });\n\n        this.subscriptions.push(\n            this.form.valueChanges.pipe(debounceTime(250), distinctUntilChanged()).subscribe(v => {\n                this.descriptor?.nextEvent(FormEventTypeEnum.ValueChange, FormEditorComponent, this, {\n                    value: v,\n                    formValue: () => this.getFormValue()\n                });\n            })\n        );\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['isFormDisabled'] && !changes['isFormDisabled'].firstChange) {\n            this.updateFormState();\n        }\n        if (changes['item'] && !changes['item'].firstChange) {\n            this.resetFormModel(this.item);\n        }\n    }\n\n    public ngOnDestroy() {\n        this.subscriptions.forEach(s => s.unsubscribe());\n\n        // emit lifecycle event\n        this.descriptor?.nextEvent(FormEventTypeEnum.ComponentLifecycle, FormEditorComponent, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_DESTROY\n        });\n        // complete emitting events\n        this.descriptor?.completeEvents();\n    }\n\n    public submit() {\n        this.submitButtonElementRef?.nativeElement.click();\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    public onSubmit(event: Event) {\n        this.formOptions.formState.submittedOn = Date.now();\n        this.formMessages = [];\n\n        const formSubmitItem = this.getFormValue();\n        if (this.form.valid) {\n            this.formSubmitEventEmitter.next({\n                success: true,\n                formItem: formSubmitItem\n            });\n            this.descriptor?.nextEvent(FormEventTypeEnum.Submit, FormEditorComponent, this, {\n                submitValid: true,\n                submitValue: formSubmitItem\n            });\n        } else {\n            // find and mark invalid tabs\n            if (this.formFields[0].type === 'tabs' && this.formFields[0].fieldGroup) {\n                for (const tab of this.formFields[0].fieldGroup) {\n                    const isInvalid = this.isAnyFieldInvalid(tab.fieldGroup);\n                    this.formOptions.formState['tab_' + (tab.id ? tab.id : (tab.props as CommonsFormlyFieldConfig).props.label) + '_invalid'] = isInvalid;\n                }\n            }\n            const event: FormEditorSubmitEvent<Item> = {success: false, formItem: formSubmitItem};\n            event.success = false;\n            this.formMessages.push(getFormEditorWarningMessage(this.translateService, 'mngEditor.invalidFormToastTitle', 'mngEditor.invalidFormToastMessage'));\n\n            this.formSubmitEventEmitter.next(event);\n            this.descriptor?.nextEvent(FormEventTypeEnum.Submit, FormEditorComponent, this, {\n                submitValid: false,\n                submitValue: formSubmitItem\n            });\n        }\n    }\n\n    public getFormValue(): Item {\n        const formValue = ObjectUtil.deepCopy(this.form.getRawValue(), {mapGettersToProperties: true});\n\n        this.descriptor?.fields.forEach(field => {\n            if (field && field.setter) {\n                const splitPath = field.property.split('.');\n                let fieldValue = formValue;\n                for (let i = 0; i < splitPath.length - 1; i++) {\n                    const currentSubPath = splitPath[i];\n                    if (typeof fieldValue[currentSubPath] !== 'object') {\n                        fieldValue[currentSubPath] = {};\n                    }\n\n                    fieldValue = fieldValue[currentSubPath];\n                }\n\n                fieldValue = fieldValue[splitPath[splitPath.length - 1]];\n                field.setter(formValue, fieldValue);\n            }\n        });\n        return formValue;\n    }\n\n    public resetFormModel(item?: Item, markAsPristine = true) {\n        if (typeof item !== 'undefined') {\n            this.originalItemPrototype = Object.getPrototypeOf(item);\n        }\n\n        const formModel = (ObjectUtil.deepCopy(item, {mapGettersToProperties: true}) as Record<string, any>) ?? {};\n\n        this.descriptor?.fields.forEach(field => {\n            if (field.getter && item) {\n                const splitPath = field.property.split('.');\n                let currentObject = formModel;\n\n                for (let i = 0; i < splitPath.length; i++) {\n                    const currentSubPath = splitPath[i];\n                    if (i === splitPath.length - 1) {\n                        currentObject[currentSubPath] = field.getter(item?.[field.property as keyof object], item);\n                    } else {\n                        if (typeof currentObject[currentSubPath] !== 'object') {\n                            currentObject[currentSubPath] = {};\n                        }\n\n                        currentObject = currentObject[currentSubPath];\n                    }\n                }\n            }\n        });\n        if (typeof this.formOptions.resetModel === 'function') {\n            // could not be initiated yet\n            this.formOptions.resetModel(this.formModel);\n        }\n        this.formModel = formModel;\n        if (markAsPristine) {\n            this.form.markAsPristine();\n        }\n    }\n\n    public getFormField(key: string) {\n        return this.findFormField(this.form, key.split('.'));\n    }\n\n    public setFormFieldValue(key: string, value: any) {\n        const control = this.getFormField(key);\n        if (control) {\n            control.setValue(value);\n            return true;\n        } else {\n            this.logger.warn(`Value was not set, because field ${key} was not found.`);\n            return false;\n        }\n    }\n\n    public patchFormFieldValue(key: string, value: any) {\n        const control = this.getFormField(key);\n        if (control) {\n            control.patchValue(value);\n            return true;\n        } else {\n            this.logger.warn(`Value was not set, because field ${key} was not found.`);\n            return false;\n        }\n    }\n\n    public resetFormFieldValue(key: string, value?: any) {\n        const control = this.getFormField(key);\n        if (control) {\n            control.reset(value);\n            return true;\n        } else {\n            this.logger.warn(`Value was not set, because field ${key} was not found.`);\n            return false;\n        }\n    }\n\n    private findFormField(control: AbstractControl, keyPath: string[]): AbstractControl | null {\n        if (keyPath.length === 0) {\n            return control;\n        }\n        if (keyPath.length === 1) {\n            return control.get(keyPath[0]);\n        }\n        let nextControl: AbstractControl | null = null;\n        if (control instanceof FormGroup) {\n            nextControl = control.get(keyPath[0]);\n        } else if (control instanceof FormArray) {\n            const idx = +keyPath[0];\n            if (!isNaN(idx)) {\n                nextControl = control.at(idx);\n            }\n        }\n\n        if (!control) {\n            return null;\n        }\n        return this.findFormField(nextControl!, keyPath.slice(1));\n    }\n\n    private isAnyFieldInvalid(fields: FormlyFieldConfig[] = []): boolean {\n        for (const field of fields) {\n            let fieldInvalid = false;\n            if (Array.isArray(field.fieldGroup)) {\n                fieldInvalid = this.isAnyFieldInvalid(field.fieldGroup);\n            } else if (typeof field.type !== 'undefined') {\n                fieldInvalid = !field.formControl?.valid;\n            }\n            if (fieldInvalid) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    private updateFormState() {\n        const isDisabled = this.isFormDisabled || this.descriptor?.disabled === true || this.descriptor?.tableviewEditorType === TableviewEditorTypeEnum.Details;\n        this.formOptions.formState.disabled = isDisabled;\n    }\n\n    /**\n     * @private Sets form state based on editor descriptor type.\n     * Possible options are: disabled, add or edit.\n     */\n    private setInitialFormState(): void {\n        if (this.descriptor?.tableviewEditorType === TableviewEditorTypeEnum.Add) {\n            this.formOptions.formState.add = true;\n        } else if (this.descriptor?.tableviewEditorType === TableviewEditorTypeEnum.Edit) {\n            this.formOptions.formState.edit = true;\n        }\n        this.updateFormState();\n    }\n}\n","<form [formGroup]=\"form\" (ngSubmit)=\"onSubmit($event)\">\n    <formly-form [form]=\"form\" [fields]=\"formFields\" [options]=\"formOptions\" [model]=\"formModel\"></formly-form>\n    <button\n        #submitButton\n        pButton\n        type=\"submit\"\n        class=\"hidden\"\n        [disabled]=\"form.disabled\"\n        [loading]=\"(submitLoading$ | async) ?? false\"\n        loadingIcon=\"pi pi-spin pi-spinner\"></button>\n</form>\n<p-messages [value]=\"formMessages\" [enableService]=\"false\"></p-messages>\n"]}