@mediusinc/mng-commons 3.6.0-rc.3 → 3.7.0-rc.0

package/esm2022/lib/descriptors/editor/editor.descriptor.mjs

@@ -1,58 +1,35 @@
 import { Subject } from 'rxjs';
-import { ObjectSerializer } from '../../api/utils';
 import { MngFormEvent } from '../../components/form/models';
 import { MngInternalError } from '../../models';
+import { TypeRegistry } from '../../registry/type.registry';
 import { I18nUtils } from '../../utils';
 import { TableviewUtil } from '../../utils/tableview.util';
-import { ModelDescriptor } from '../model.descriptor';
+import { ModelDescriptor } from '../model';
 import { FieldInputTypeEnum, TableviewEditorTypeEnum } from '../types';
-import { AFieldDescriptor, FieldActionDescriptor, FieldGroupDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, FieldTabGroupDescriptor } from './field.descriptor';
-export class EditorDescriptor {
-    static { this.defaultGroupName = '_default'; }
+import { FieldActionDescriptor } from './field-action.descriptor';
+import { AFieldDescriptor } from './field-base.descriptor';
+import { FieldGroupDescriptor, FieldTabGroupDescriptor } from './field-group.descriptor';
+import { FieldLookupDescriptor, FieldLookupEnumDescriptor, fieldLookupGetProviderCfgObj } from './field-lookup.descriptor';
+import { FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, fieldManyToManyGetProviderCfgObj } from './field-many.descriptor';
+import { FieldInputDescriptor } from './field.descriptor';
+import { EDITOR_DEFAULT_GROUP_NAME } from './internal/editor.model';
+export class EditorDescriptorInst {
+    static { this.defaultGroupName = EDITOR_DEFAULT_GROUP_NAME; }
     /**
      * Creates new instance of editor descriptor.
-     * @param modelType Model's class.
-     * @param idProperty Id property representing model (optional).
-     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
+     * @param model Model descriptor.
      * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).
-     * @param i18nBaseKey Base key for translations.
      */
-    constructor(modelType, idProperty, titleProperty, tableviewEditorType = TableviewEditorTypeEnum.None, i18nBaseKey) {
+    constructor(model, tableviewEditorType = TableviewEditorTypeEnum.None) {
         /** @ignore */ this._tabs = [];
         /** @ignore */ this._groups = [];
         /** @ignore */ this._fields = [];
         /** @ignore */ this._disabled = false;
         /** @ignore */ this._isLocalized = false;
         /** @ignore */ this._eventsSubject = new Subject();
-        this._modelType = modelType;
-        this._model = new ModelDescriptor(modelType, idProperty, titleProperty, i18nBaseKey);
+        this._model = model;
         this._tableviewEditorType = tableviewEditorType;
     }
-    /**
-     * Creates editor descriptor automatically based on openapi model's attributes definition which is automatically extracted. All fields will be included.
-     * @param modelType Model's class.
-     * @param idProperty Id property representing model (optional).
-     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
-     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
-     */
-    static from(modelType, idProperty, titleProperty, tableEditorType = TableviewEditorTypeEnum.None) {
-        return EditorDescriptor.fromModelWithAttributes(modelType, TableviewUtil.getAttributeDefMap(modelType), titleProperty, idProperty, tableEditorType);
-    }
-    /**
-     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.
-     * @param modelType Model's class.
-     * @param attributes List of attribute definitions from which fields should be created.
-     * @param idProperty Id property representing model (optional).
-     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
-     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
-     */
-    static fromModelWithAttributes(modelType, attributes, idProperty, titleProperty, tableEditorType = TableviewEditorTypeEnum.None) {
-        const descriptor = new EditorDescriptor(modelType, idProperty, titleProperty, tableEditorType);
-        attributes
-            .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
-            .forEach(attr => descriptor.upsertFieldFromAttributeDef(attr, descriptor.fields.find(col => col.property === attr.name)));
-        return descriptor;
-    }
     /**
      * Model descriptor for editor.
      */
@@ -92,11 +69,8 @@ export class EditorDescriptor {
     get localizationLocalizationProperty() {
         return this._localizationLocalizationProperty;
     }
-    get localizationBeanType() {
-        return this._localizationModelType;
-    }
-    get localeLookup() {
-        return this._localeLookup;
+    get localizationModel() {
+        return this._localizationModel;
     }
     /**
      * Creates new tab group. Next added fields are added to newly created tab group.
@@ -129,29 +103,31 @@ export class EditorDescriptor {
         return fieldGroup;
     }
     /**
-     * Adds field by the descriptor.
-     * @param field Field descriptor.
+     * Gets field by the model property name.
+     * @param property Model property name.
      */
-    addFieldDescriptor(field) {
-        this.createDefaultGroup();
-        this._fields.push(field);
-        this._currentGroup?.addField(field);
-        return this;
+    getField(property) {
+        return this.getFieldUnsafe(property);
     }
     /**
-     * Adds field by the model property name.
+     * Gets field by the model property name (UNSAFE).
      * @param property Model property name.
      */
-    addField(property) {
-        const field = new FieldInputDescriptor(this, property);
-        this.addFieldDescriptor(field);
-        return field;
+    getFieldUnsafe(property) {
+        return this._fields.find(f => f.property === property) ?? null;
     }
     /**
      * Removes field by the model property name.
      * @param property Model property name.
      */
     removeField(property) {
+        return this.removeFieldUnsafe(property);
+    }
+    /**
+     * Removes field by the model property name (UNSAFE).
+     * @param property Model property name.
+     */
+    removeFieldUnsafe(property) {
         const fieldIdx = this._fields.findIndex(f => f.property === property);
         if (fieldIdx < 0) {
             throw new MngInternalError(`Field ${property} does not exist.`, { name: 'EditorDescriptorError' });
@@ -166,11 +142,37 @@ export class EditorDescriptor {
         this._fields.splice(fieldIdx, 1);
     }
     /**
-     * Gets field by the model property name.
+     * Adds field by the descriptor.
+     * @param field Field descriptor.
+     */
+    addFieldDescriptor(field) {
+        this.createDefaultGroup();
+        this._fields.push(field);
+        this._currentGroup?.addField(field);
+        return this;
+    }
+    /**
+     * Adds field by the model property name.
      * @param property Model property name.
      */
-    getField(property) {
-        return this._fields.find(f => f.property === property) ?? null;
+    addField(property) {
+        const field = new FieldInputDescriptor(this, property);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    /**
+     * Adds field by the model property name (UNSAFE). Property is not checked on editor model.
+     * Use {addField} for safe usage.
+     * @param property Model property name.
+     */
+    addFieldUnsafe(property) {
+        const field = new FieldInputDescriptor(this, property);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFields(...properties) {
+        properties.forEach(p => this.addField(p));
+        return this;
     }
     addFieldAction(actionName) {
         const field = new FieldActionDescriptor(this, actionName);
@@ -180,22 +182,54 @@ export class EditorDescriptor {
     /**
      * Adds lookup field.
      * @param property Model property name.
-     * @param modelType Model's class type (must be registered in ObjectSerializer!).
+     * @param type Model's class type.
      */
-    addFieldLookup(property, modelType) {
-        const field = new FieldLookupDescriptor(this, property, modelType);
+    addFieldLookup(property, type) {
+        return this.addFieldLookupUnsafe(property, type);
+    }
+    /**
+     * Adds lookup field (UNSAFE).
+     * @param property Model property name.
+     * @param type Model's class type.
+     */
+    addFieldLookupUnsafe(property, type) {
+        const field = new FieldLookupDescriptor(this, property, {
+            type: type
+        });
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldLookupWithPropertyAsValueUnsafe(property, optionsValueProperty) {
+        const field = new FieldLookupDescriptor(this, property, {
+            optionsValueProperty: optionsValueProperty
+        });
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldLookupWithProvider(property, provider, type) {
+        return this.addFieldLookupWithProviderUnsafe(property, provider, type);
+    }
+    addFieldLookupWithProviderUnsafe(property, provider, type) {
+        const cfg = fieldLookupGetProviderCfgObj(provider);
+        const field = new FieldLookupDescriptor(this, property, {
+            type: type,
+            ...cfg
+        });
         this.addFieldDescriptor(field);
         return field;
     }
+    addFieldLookupEnum(property, enumType, options, nameAsValue = false, optionsTitlePath) {
+        return this.addFieldLookupEnumUnsafe(property, enumType, options, nameAsValue, optionsTitlePath);
+    }
     /**
      * Adds enum lookup field.
      * @param property Model's property name.
-     * @param enumType Type of enum (must be registered in ObjectSerializer!).
+     * @param enumType Type of enum.
      * @param options Provides subset of enum's available constants.
      * @param nameAsValue If constant's name should be used as final value of the enum. Primarily, constant's value will be used.
      * @param optionsTitlePath Title key path from where translations are provided. If null, the enum's values won't be translated.
      */
-    addFieldLookupEnum(property, enumType, options, nameAsValue = false, optionsTitlePath) {
+    addFieldLookupEnumUnsafe(property, enumType, options, nameAsValue = false, optionsTitlePath) {
         const field = new FieldLookupEnumDescriptor(this, property, enumType, options, nameAsValue, optionsTitlePath);
         this.addFieldDescriptor(field);
         return field;
@@ -206,6 +240,14 @@ export class EditorDescriptor {
      * @param tableviewDescriptor Tableview descriptor for related model.
      */
     addFieldManyEditor(property, tableviewDescriptor) {
+        return this.addFieldManyEditorUnsafe(property, tableviewDescriptor);
+    }
+    /**
+     * Adds table/details/add/edit field for one-to-many (1:n) relations (UNSAFE).
+     * @param property Model's property name.
+     * @param tableviewDescriptor Tableview descriptor for related model.
+     */
+    addFieldManyEditorUnsafe(property, tableviewDescriptor) {
         const field = new FieldManyEditorDescriptor(this, property, tableviewDescriptor);
         this.addFieldDescriptor(field);
         return field;
@@ -217,10 +259,30 @@ export class EditorDescriptor {
      * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.
      */
     addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor) {
+        return this.addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor);
+    }
+    /**
+     * Adds tables for many-to-many (m:n) relations (UNSAFE).
+     * @param property Model's property name.
+     * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.
+     * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.
+     */
+    addFieldManyToManyEditorUnsafe(property, mainTableDescriptor, lookupTableDescriptor) {
         const field = new FieldManyToManyEditorDescriptor(this, property, mainTableDescriptor, lookupTableDescriptor);
         this.addFieldDescriptor(field);
         return field;
     }
+    addFieldManyToManyEditorWithProvider(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        return this.addFieldManyToManyEditorWithProviderUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider);
+    }
+    addFieldManyToManyEditorWithProviderUnsafe(property, mainTableDescriptor, lookupTableDescriptor, lookupDataProvider) {
+        const cfg = fieldManyToManyGetProviderCfgObj(lookupDataProvider);
+        const field = new FieldManyToManyEditorDescriptor(this, property, mainTableDescriptor, lookupTableDescriptor, {
+            ...cfg
+        });
+        this.addFieldDescriptor(field);
+        return field;
+    }
     /**
      * Disables field on editor.
      * @param disabled
@@ -244,7 +306,7 @@ export class EditorDescriptor {
      * Creates a copy of editor descriptor object.
      */
     copy() {
-        const editor = new EditorDescriptor(this.model.type, this.model.idPropertyName, this.model.titlePropertyName, this.tableviewEditorType);
+        const editor = new EditorDescriptorInst(this.model.copy(), this.tableviewEditorType);
         for (const tabGroup of this._tabs) {
             editor.createTabGroupDescriptor(tabGroup.copy());
         }
@@ -288,7 +350,7 @@ export class EditorDescriptor {
     createDefaultGroup() {
         this.createDefaultTabGroup();
         if (this._currentTabGroup?.fields.length === 0) {
-            this.createFieldGroup(EditorDescriptor.defaultGroupName, null);
+            this.createFieldGroup(EditorDescriptorInst.defaultGroupName, null);
         }
     }
     /**
@@ -297,7 +359,7 @@ export class EditorDescriptor {
      */
     createDefaultTabGroup() {
         if (this._tabs.length === 0) {
-            this.createTabGroup(EditorDescriptor.defaultGroupName, 'general.general');
+            this.createTabGroup(EditorDescriptorInst.defaultGroupName, 'general.general');
         }
     }
     /**
@@ -307,10 +369,16 @@ export class EditorDescriptor {
      * @param args additional parameters for field
      */
     withFieldModifiedType(property, fieldType, ...args) {
-        const attribute = TableviewUtil.getAttributeDefMap(this._modelType).find(attribute => attribute.name === property);
+        return this.withFieldModifiedTypeUnsafe(property, fieldType, ...args);
+    }
+    withFieldModifiedTypeUnsafe(property, fieldType, ...args) {
+        if (!this.model.type) {
+            throw new MngInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attribute = TableviewUtil.getAttributeDefMap(this.model.type).find(attribute => attribute.name === property);
         if (attribute) {
             attribute.fieldType = fieldType;
-            this.upsertFieldFromAttributeDef(attribute, this.fields.find(fi => fi.property === property), ...args);
+            EditorDescriptorInst.upsertFieldFromAttributeDef(this, attribute, this.fields.find(fi => fi.property === property), ...args);
         }
         return this;
     }
@@ -320,14 +388,21 @@ export class EditorDescriptor {
      * @param enumType type of enum for new field
      * @param optionsTitlePath
      * @param values
+     * @param nameAsValue
      */
     withFieldModifiedEnum(property, enumType, optionsTitlePath, values, nameAsValue = false) {
-        const attribute = TableviewUtil.getAttributeDefMap(this._modelType).find(a => a.name === property);
+        return this.withFieldModifiedEnumUnsafe(property, enumType, optionsTitlePath, values, nameAsValue);
+    }
+    withFieldModifiedEnumUnsafe(property, enumType, optionsTitlePath, values, nameAsValue = false) {
+        if (!this.model.type) {
+            throw new MngInternalError(`withFieldModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
+        }
+        const attribute = TableviewUtil.getAttributeDefMap(this.model.type).find(a => a.name === property);
         if (attribute) {
             attribute.fieldType = FieldInputTypeEnum.Radio;
             const field = this.fields.find(f => f.property === property);
             if (field && field instanceof FieldInputDescriptor) {
-                field.asRadioFromEnum(enumType ?? ObjectSerializer.get().findEnum(attribute.type), optionsTitlePath, values, nameAsValue);
+                field.asRadioFromEnum(enumType ?? TypeRegistry.get().findEnum(attribute.type), optionsTitlePath, values, nameAsValue);
             }
         }
         return this;
@@ -335,28 +410,56 @@ export class EditorDescriptor {
     /**
      * Modifies selected field with lookup field.
      * @param property Model's property name.
-     * @param modelType model type of field
      * @param lookupProvider provider to be added to field
      * @param titleProperty
      */
-    withFieldModifiedLookup(property, modelType, lookupProvider, titleProperty) {
-        this.removeField(property);
-        const field = this.addFieldLookup(property, modelType).asAutocomplete().withLookupDataProvider(lookupProvider);
+    withFieldModifiedLookupWithProvider(property, lookupProvider, titleProperty) {
+        return this.withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, titleProperty);
+    }
+    withFieldModifiedLookupWithProviderUnsafe(property, lookupProvider, titleProperty) {
+        this.removeFieldUnsafe(property);
+        const field = this.addFieldLookupWithProviderUnsafe(property, lookupProvider).asAutocomplete();
         if (titleProperty) {
-            field.withItemsLabelProperty(titleProperty);
+            field.withOptionsLabelProperty(titleProperty);
         }
         return this;
     }
+    /**
+     * This method takes care of displaying correct/localized data in the editor
+     * @param property property that tells us where on the model are localizations accessible
+     * @param model Model for localizations
+     * @param localeProperty property by which we find the locale
+     */
+    localized(property, model, localeProperty) {
+        return this.localizedUnsafe(property, model, localeProperty);
+    }
+    localizedUnsafe(property, model, localeProperty) {
+        this._localizationLocalizationProperty = property;
+        this._localizationModel = model;
+        this._localizationLocaleProperty = localeProperty;
+        this._isLocalized = true;
+        return this;
+    }
+    nextEvent(type, cmpType, cmpInstance, data) {
+        this._eventsSubject.next(new MngFormEvent(type, cmpType, cmpInstance, data));
+    }
+    completeEvents() {
+        this._eventsSubject.complete();
+    }
+    get events$() {
+        return this._eventsSubject.asObservable();
+    }
     /**
      * Generates field based on attribute definition, used for auto model
+     * @param descriptor Editor descriptor instance.
      * @param attribute Attribute definition.
      * @param field Optional, if defined will be replaced, otherwise new will be generated.
      * @param args Optional additional arguments mapped to filed type. Arguments depend on possible arguments on fields.
      * @internal
      */
-    upsertFieldFromAttributeDef(attribute, field, ...args) {
+    static upsertFieldFromAttributeDef(descriptor, attribute, field, ...args) {
         if (field == null) {
-            field = this.addField(attribute.name);
+            field = descriptor.addFieldUnsafe(attribute.name);
         }
         if (field instanceof FieldInputDescriptor) {
             if (attribute.enumType) {
@@ -368,34 +471,44 @@ export class EditorDescriptor {
         }
         return field;
     }
-    /**
-     * This method takes care of displaying correct/localized data in the editor
-     * @param localizationsProperty property that tells us where on the model are localizations accessible
-     * @param localeProperty property by which we find the locale
-     * @param localizationModelType model type for localizations if it is different from the whole model
-     * @param localeLookup lookup provider for locales supported by the application.
-     */
-    localized(localizationsProperty = 'localizations', localeProperty = 'locale', localizationModelType, localeLookup) {
-        this._localizationLocalizationProperty = localizationsProperty;
-        this._localizationLocaleProperty = localeProperty;
-        this._isLocalized = true;
-        this._localeLookup = localeLookup;
-        if (localizationModelType) {
-            this._localizationModelType = localizationModelType;
-        }
-        else {
-            this._localizationModelType = this._modelType;
-        }
-        return this;
+}
+export class EditorDescriptor extends EditorDescriptorInst {
+    constructor() {
+        super(ModelDescriptor.create());
     }
-    nextEvent(type, cmpType, cmpInstance, data) {
-        this._eventsSubject.next(new MngFormEvent(type, cmpType, cmpInstance, data));
+    static create(idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        return new EditorDescriptorInst(ModelDescriptor.create(idProperty, titleProperty, i18nBaseKey), tableviewEditorType);
     }
-    completeEvents() {
-        this._eventsSubject.complete();
+    static fromClass(type, idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        return new EditorDescriptorInst(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey), tableviewEditorType);
     }
-    get events$() {
-        return this._eventsSubject.asObservable();
+    static fromModel(model, tableviewEditorType = TableviewEditorTypeEnum.None) {
+        return new EditorDescriptorInst(model, tableviewEditorType);
+    }
+    /**
+     * Creates editor descriptor automatically based on openapi model's attributes definition which is automatically extracted. All fields will be included.
+     * @param type Model's class.
+     * @param idProperty Id property representing model (optional).
+     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
+     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
+     */
+    static fromClassWithAutoAttrsDef(type, idProperty, titleProperty, tableEditorType = TableviewEditorTypeEnum.None) {
+        return EditorDescriptor.fromClassWithCustomAttrsDef(type, TableviewUtil.getAttributeDefMap(type), idProperty, titleProperty, tableEditorType);
+    }
+    /**
+     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.
+     * @param type Model's class.
+     * @param attributes List of attribute definitions from which fields should be created.
+     * @param idProperty Id property representing model (optional).
+     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.
+     * @param tableEditorType Type of editor in tableview (add, edit, view or none).
+     */
+    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty, tableEditorType = TableviewEditorTypeEnum.None) {
+        const descriptor = EditorDescriptor.fromClass(type, idProperty, titleProperty, undefined, tableEditorType);
+        attributes
+            .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
+            .forEach(attr => EditorDescriptorInst.upsertFieldFromAttributeDef(descriptor, attr, descriptor.fields.find(col => col.property === attr.name)));
+        return descriptor;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.descriptor.js","sourceRoot":"","sources":["../../../../../src/lib/descriptors/editor/editor.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\n\nimport {Observable, Subject} from 'rxjs';\n\nimport {MediusQueryParam} from '../../api/models';\nimport {ObjectSerializer} from '../../api/utils';\nimport {MngFieldEventData, MngFormEvent, MngFormEventTypeEnum} from '../../components/form/models';\nimport {ILookupDataProvider} from '../../data-providers';\nimport {MngInternalError} from '../../models';\nimport {TableviewAttributeDef} from '../../models';\nimport {ClassType, EnumConstantType, EnumType, MngFieldValidationMessage, MngFieldValidator} from '../../types';\nimport {I18nUtils} from '../../utils';\nimport {TableviewUtil} from '../../utils/tableview.util';\nimport {ModelDescriptor} from '../model.descriptor';\nimport {TableDescriptor} from '../table';\nimport {TableviewDescriptor} from '../tableview';\nimport {FieldInputTypeEnum, TableviewEditorTypeEnum} from '../types';\nimport {\n    AFieldDescriptor,\n    FieldActionDescriptor,\n    FieldGroupDescriptor,\n    FieldInputDescriptor,\n    FieldLookupDescriptor,\n    FieldLookupEnumDescriptor,\n    FieldManyEditorDescriptor,\n    FieldManyToManyEditorDescriptor,\n    FieldTabGroupDescriptor\n} from './field.descriptor';\n\nexport class EditorDescriptor<T> {\n    public static readonly defaultGroupName = '_default';\n\n    /** @ignore */ protected readonly _model: ModelDescriptor<T>;\n    /** @ignore */ protected readonly _modelType: ClassType<T>;\n    /** @ignore */ protected readonly _tableviewEditorType: TableviewEditorTypeEnum;\n    /** @ignore */ protected readonly _tabs: Array<FieldTabGroupDescriptor<T>> = [];\n    /** @ignore */ protected readonly _groups: Array<FieldGroupDescriptor<T>> = [];\n    /** @ignore */ protected _fields: Array<AFieldDescriptor<any, T>> = [];\n    /** @ignore */ protected _currentTabGroup?: FieldTabGroupDescriptor<T>;\n    /** @ignore */ protected _currentGroup?: FieldGroupDescriptor<T>;\n\n    /** @ignore */ protected _disabled = false;\n\n    /** @ignore */ protected _isLocalized = false;\n    /** @ignore */ protected _localizationLocaleProperty?: string;\n    /** @ignore */ protected _localizationLocalizationProperty?: string;\n    /** @ignore */ protected _localizationModelType?: ClassType<any>;\n    /** @ignore */ protected _localeLookup?: (queryParam?: MediusQueryParam, service?: any, search?: string) => Observable<Array<string>>;\n\n    /** @ignore */ protected readonly _eventsSubject = new Subject<MngFormEvent<T>>();\n\n    /**\n     * Creates new instance of editor descriptor.\n     * @param modelType Model's class.\n     * @param idProperty Id property representing model (optional).\n     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.\n     * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).\n     * @param i18nBaseKey Base key for translations.\n     */\n    constructor(\n        modelType: ClassType<T>,\n        idProperty?: string,\n        titleProperty?: string,\n        tableviewEditorType = TableviewEditorTypeEnum.None,\n        i18nBaseKey?: string | ClassType<unknown>\n    ) {\n        this._modelType = modelType;\n        this._model = new ModelDescriptor<T>(modelType, idProperty, titleProperty, i18nBaseKey);\n        this._tableviewEditorType = tableviewEditorType;\n    }\n\n    /**\n     * Creates editor descriptor automatically based on openapi model's attributes definition which is automatically extracted. All fields will be included.\n     * @param modelType Model's class.\n     * @param idProperty Id property representing model (optional).\n     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.\n     * @param tableEditorType Type of editor in tableview (add, edit, view or none).\n     */\n    public static from<T>(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableEditorType = TableviewEditorTypeEnum.None): EditorDescriptor<T> {\n        return EditorDescriptor.fromModelWithAttributes(modelType, TableviewUtil.getAttributeDefMap(modelType), titleProperty, idProperty, tableEditorType);\n    }\n\n    /**\n     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.\n     * @param modelType Model's class.\n     * @param attributes List of attribute definitions from which fields should be created.\n     * @param idProperty Id property representing model (optional).\n     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.\n     * @param tableEditorType Type of editor in tableview (add, edit, view or none).\n     */\n    public static fromModelWithAttributes<T>(\n        modelType: ClassType<T>,\n        attributes: TableviewAttributeDef[],\n        idProperty?: string,\n        titleProperty?: string,\n        tableEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptor<T> {\n        const descriptor = new EditorDescriptor(modelType, idProperty, titleProperty, tableEditorType);\n\n        attributes\n            .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))\n            .forEach(attr =>\n                descriptor.upsertFieldFromAttributeDef(\n                    attr,\n                    descriptor.fields.find(col => col.property === attr.name)\n                )\n            );\n        return descriptor;\n    }\n\n    /**\n     * Model descriptor for editor.\n     */\n    public get model() {\n        return this._model;\n    }\n\n    /**\n     * Editor's tabs.\n     */\n    public get tabs() {\n        return this._tabs;\n    }\n\n    /**\n     * Editor's fields.\n     */\n    public get fields() {\n        return this._fields;\n    }\n\n    /**\n     * Type of editor for tableview.\n     */\n    public get tableviewEditorType() {\n        return this._tableviewEditorType;\n    }\n\n    /**\n     * If editor is disabled.\n     */\n    public get disabled() {\n        return this._disabled;\n    }\n\n    public get isLocalized() {\n        return this._isLocalized;\n    }\n\n    public get localizationLocaleProperty() {\n        return this._localizationLocaleProperty;\n    }\n\n    public get localizationLocalizationProperty() {\n        return this._localizationLocalizationProperty;\n    }\n\n    public get localizationBeanType() {\n        return this._localizationModelType;\n    }\n\n    public get localeLookup() {\n        return this._localeLookup;\n    }\n\n    /**\n     * Creates new tab group. Next added fields are added to newly created tab group.\n     * @param name Name of the group.\n     * @param title Title key for the tab.\n     */\n    public createTabGroup(name: string, title?: string): FieldTabGroupDescriptor<T> {\n        const tabGroup = new FieldTabGroupDescriptor<T>(this, name);\n        if (!title) {\n            title = I18nUtils.Type.getTabKey(this.model.i18nBaseKey, name);\n        }\n        tabGroup.withTitle(title);\n        this.createTabGroupDescriptor(tabGroup);\n        return tabGroup;\n    }\n\n    /**\n     * Creates new field group. Next added fields are added to newly created field group.\n     * @param name Name of the group.\n     * @param title Title key for the group.\n     */\n    public createFieldGroup(name: string, title?: string | null): FieldGroupDescriptor<T> {\n        const fieldGroup = new FieldGroupDescriptor<T>(this, name);\n        if (title !== null) {\n            if (!title) {\n                title = I18nUtils.Type.getGroupKey(this.model.i18nBaseKey, name);\n            }\n            fieldGroup.withTitle(title);\n        }\n        this.createFieldGroupDescriptor(fieldGroup);\n        return fieldGroup;\n    }\n\n    /**\n     * Adds field by the descriptor.\n     * @param field Field descriptor.\n     */\n    public addFieldDescriptor<FT, FVT = FT>(field: AFieldDescriptor<FT, T, FVT>): this {\n        this.createDefaultGroup();\n        this._fields.push(field);\n        this._currentGroup?.addField(field);\n        return this;\n    }\n\n    /**\n     * Adds field by the model property name.\n     * @param property Model property name.\n     */\n    public addField(property: string): FieldInputDescriptor<T> {\n        const field = new FieldInputDescriptor<T>(this, property);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Removes field by the model property name.\n     * @param property Model property name.\n     */\n    public removeField(property: string): void {\n        const fieldIdx = this._fields.findIndex(f => f.property === property);\n        if (fieldIdx < 0) {\n            throw new MngInternalError(`Field ${property} does not exist.`, {name: 'EditorDescriptorError'});\n        }\n        for (const group of this._groups) {\n            const groupFieldIdx = group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);\n            if (groupFieldIdx >= 0) {\n                group.fields.splice(groupFieldIdx, 1);\n                break;\n            }\n        }\n        this._fields.splice(fieldIdx, 1);\n    }\n\n    /**\n     * Gets field by the model property name.\n     * @param property Model property name.\n     */\n    public getField(property: string): AFieldDescriptor<any, T> | null {\n        return this._fields.find(f => f.property === property) ?? null;\n    }\n\n    public addFieldAction(actionName: string): FieldActionDescriptor<T> {\n        const field = new FieldActionDescriptor<T>(this, actionName);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Adds lookup field.\n     * @param property Model property name.\n     * @param modelType Model's class type (must be registered in ObjectSerializer!).\n     */\n    public addFieldLookup<FT>(property: string, modelType: ClassType<FT>): FieldLookupDescriptor<FT, T> {\n        const field = new FieldLookupDescriptor<FT, T>(this, property, modelType);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Adds enum lookup field.\n     * @param property Model's property name.\n     * @param enumType Type of enum (must be registered in ObjectSerializer!).\n     * @param options Provides subset of enum's available constants.\n     * @param nameAsValue If constant's name should be used as final value of the enum. Primarily, constant's value will be used.\n     * @param optionsTitlePath Title key path from where translations are provided. If null, the enum's values won't be translated.\n     */\n    public addFieldLookupEnum(\n        property: string,\n        enumType: EnumType,\n        options?: Array<EnumConstantType>,\n        nameAsValue = false,\n        optionsTitlePath?: string | null\n    ): FieldLookupEnumDescriptor<T> {\n        const field = new FieldLookupEnumDescriptor(this, property, enumType, options, nameAsValue, optionsTitlePath);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Adds table/details/add/edit field for one-to-many (1:n) relations.\n     * @param property Model's property name.\n     * @param tableviewDescriptor Tableview descriptor for related model.\n     */\n    public addFieldManyEditor<FT>(property: string, tableviewDescriptor: TableviewDescriptor<FT>): FieldManyEditorDescriptor<FT, T> {\n        const field = new FieldManyEditorDescriptor(this, property, tableviewDescriptor);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Adds tables for many-to-many (m:n) relations.\n     * @param property Model's property name.\n     * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.\n     * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.\n     */\n    public addFieldManyToManyEditor<FT>(\n        property: string,\n        mainTableDescriptor: TableDescriptor<FT>,\n        lookupTableDescriptor: TableDescriptor<FT>\n    ): FieldManyToManyEditorDescriptor<FT, T> {\n        const field = new FieldManyToManyEditorDescriptor(this, property, mainTableDescriptor, lookupTableDescriptor);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Disables field on editor.\n     * @param disabled\n     */\n    public withDisabled(disabled = true): this {\n        this._disabled = disabled;\n        return this;\n    }\n\n    /**\n     * Adds group validator to editor.\n     * @param name Name of the validation.\n     * @param validator Field validator function.\n     * @param message Field validation message.\n     */\n    public addValidation(name: string, validator?: MngFieldValidator, message?: MngFieldValidationMessage) {\n        if (this._currentGroup) {\n            this._currentGroup.withValidation(name, validator, message);\n        }\n    }\n\n    /**\n     * Creates a copy of editor descriptor object.\n     */\n    public copy(): EditorDescriptor<T> {\n        const editor = new EditorDescriptor<T>(this.model.type, this.model.idPropertyName, this.model.titlePropertyName, this.tableviewEditorType);\n        for (const tabGroup of this._tabs) {\n            editor.createTabGroupDescriptor(tabGroup.copy());\n        }\n        for (const tabGroup of editor._tabs) {\n            for (const fieldGroup of tabGroup.fields) {\n                editor._fields.push(...fieldGroup.fields);\n            }\n            editor._groups.push(...tabGroup.fields);\n        }\n        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];\n        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];\n        editor._disabled = this._disabled;\n        return editor;\n    }\n\n    /**\n     * Created group from field group descriptor.\n     * @param fieldGroup Field group descriptor.\n     * @internal\n     */\n    public createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<T>): this {\n        this.createDefaultTabGroup();\n        this._currentGroup = fieldGroup;\n        this._groups.push(fieldGroup);\n        this._currentTabGroup?.addField(fieldGroup);\n        return this;\n    }\n\n    /**\n     * Creates tab group from tab group descriptor.\n     * @param tabGroup Tab group descriptor.\n     * @internal\n     */\n    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<T>): this {\n        this._currentTabGroup = tabGroup;\n        this._tabs.push(tabGroup);\n        return this;\n    }\n\n    /**\n     * Creates default field group.\n     * @internal\n     */\n    private createDefaultGroup() {\n        this.createDefaultTabGroup();\n        if (this._currentTabGroup?.fields.length === 0) {\n            this.createFieldGroup(EditorDescriptor.defaultGroupName, null);\n        }\n    }\n\n    /**\n     * Creates default tab group.\n     * @internal\n     */\n    private createDefaultTabGroup() {\n        if (this._tabs.length === 0) {\n            this.createTabGroup(EditorDescriptor.defaultGroupName, 'general.general');\n        }\n    }\n\n    /**\n     * Modifies selected field by field property. For enums use {withFieldModifiedEnum} instead.\n     * @param property Model's property name.\n     * @param fieldType new field type for selected field\n     * @param args additional parameters for field\n     */\n    public withFieldModifiedType(property: string, fieldType: FieldInputTypeEnum, ...args: any[]): this {\n        const attribute = TableviewUtil.getAttributeDefMap(this._modelType).find(attribute => attribute.name === property);\n        if (attribute) {\n            attribute.fieldType = fieldType;\n            this.upsertFieldFromAttributeDef(\n                attribute,\n                this.fields.find(fi => fi.property === property),\n                ...args\n            );\n        }\n        return this;\n    }\n\n    /**\n     * Modifies selected field with enum type.\n     * @param property Model's property name.\n     * @param enumType type of enum for new field\n     * @param optionsTitlePath\n     * @param values\n     */\n    public withFieldModifiedEnum(property: string, enumType?: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue = false): this {\n        const attribute = TableviewUtil.getAttributeDefMap(this._modelType).find(a => a.name === property);\n        if (attribute) {\n            attribute.fieldType = FieldInputTypeEnum.Radio;\n            const field = this.fields.find(f => f.property === property);\n            if (field && field instanceof FieldInputDescriptor) {\n                field.asRadioFromEnum(enumType ?? (ObjectSerializer.get().findEnum(attribute.type) as EnumType), optionsTitlePath, values, nameAsValue);\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Modifies selected field with lookup field.\n     * @param property Model's property name.\n     * @param modelType model type of field\n     * @param lookupProvider provider to be added to field\n     * @param titleProperty\n     */\n    public withFieldModifiedLookup<MT>(property: string, modelType: ClassType<MT>, lookupProvider: ILookupDataProvider<any, any>, titleProperty?: string): this {\n        this.removeField(property);\n        const field = this.addFieldLookup(property, modelType).asAutocomplete().withLookupDataProvider(lookupProvider);\n\n        if (titleProperty) {\n            (field as FieldLookupDescriptor<any, any>).withItemsLabelProperty(titleProperty);\n        }\n\n        return this;\n    }\n\n    /**\n     * Generates field based on attribute definition, used for auto model\n     * @param attribute Attribute definition.\n     * @param field Optional, if defined will be replaced, otherwise new will be generated.\n     * @param args Optional additional arguments mapped to filed type. Arguments depend on possible arguments on fields.\n     * @internal\n     */\n    private upsertFieldFromAttributeDef(attribute: TableviewAttributeDef, field?: AFieldDescriptor<any, T>, ...args: any[]): AFieldDescriptor<any, T> {\n        if (field == null) {\n            field = this.addField(attribute.name);\n        }\n\n        if (field instanceof FieldInputDescriptor) {\n            if (attribute.enumType) {\n                return field.asRadioFromEnum(attribute.enumType);\n            } else {\n                return field.asType(attribute.fieldType ?? TableviewUtil.toFieldInputTypeFromColumnType(attribute.columnType, attribute.columnDisplayType), ...args);\n            }\n        }\n\n        return field;\n    }\n\n    /**\n     * This method takes care of displaying correct/localized data in the editor\n     * @param localizationsProperty property that tells us where on the model are localizations accessible\n     * @param localeProperty property by which we find the locale\n     * @param localizationModelType model type for localizations if it is different from the whole model\n     * @param localeLookup lookup provider for locales supported by the application.\n     */\n    public localized<S>(\n        localizationsProperty = 'localizations',\n        localeProperty = 'locale',\n        localizationModelType?: ClassType<any>,\n        localeLookup?: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<string>>\n    ): this {\n        this._localizationLocalizationProperty = localizationsProperty;\n        this._localizationLocaleProperty = localeProperty;\n        this._isLocalized = true;\n        this._localeLookup = localeLookup;\n\n        if (localizationModelType) {\n            this._localizationModelType = localizationModelType;\n        } else {\n            this._localizationModelType = this._modelType;\n        }\n        return this;\n    }\n\n    public nextEvent(type: MngFormEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: MngFieldEventData<T>) {\n        this._eventsSubject.next(new MngFormEvent(type, cmpType, cmpInstance, data));\n    }\n\n    public completeEvents() {\n        this._eventsSubject.complete();\n    }\n\n    public get events$() {\n        return this._eventsSubject.asObservable();\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.descriptor.js","sourceRoot":"","sources":["../../../../../src/lib/descriptors/editor/editor.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\n\nimport {Subject} from 'rxjs';\n\nimport {MngFieldEventData, MngFormEvent, MngFormEventTypeEnum} from '../../components/form/models';\nimport {ILookupDataProvider, ITableDataProvider} from '../../data-providers';\nimport {MngInternalError, TableviewAttributeDef} from '../../models';\nimport {TypeRegistry} from '../../registry/type.registry';\nimport {ArrayItemType, ClassType, EnumConstantType, EnumType, IdType, MngFieldValidationMessage, MngFieldValidator, Nullable} from '../../types';\nimport {I18nUtils} from '../../utils';\nimport {TableviewUtil} from '../../utils/tableview.util';\nimport {ModelDescriptor} from '../model';\nimport {TableDescriptorInst} from '../table';\nimport {TableviewDescriptorInst} from '../tableview';\nimport {FieldInputTypeEnum, TableviewEditorTypeEnum} from '../types';\nimport {FieldActionDescriptor} from './field-action.descriptor';\nimport {AFieldDescriptor} from './field-base.descriptor';\nimport {FieldGroupDescriptor, FieldTabGroupDescriptor} from './field-group.descriptor';\nimport {FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldLookupProviderType, fieldLookupGetProviderCfgObj} from './field-lookup.descriptor';\nimport {FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, fieldManyToManyGetProviderCfgObj} from './field-many.descriptor';\nimport {FieldInputDescriptor, FieldInputDescriptorType} from './field.descriptor';\nimport {IFieldsManageInterface} from './internal/editor-fields.model';\nimport {EDITOR_DEFAULT_GROUP_NAME, IEditorDescriptorInternal} from './internal/editor.model';\n\nexport class EditorDescriptorInst<EditorModel> implements IEditorDescriptorInternal<EditorModel>, IFieldsManageInterface<EditorModel> {\n    public static readonly defaultGroupName = EDITOR_DEFAULT_GROUP_NAME;\n\n    /** @ignore */ protected readonly _model: ModelDescriptor<EditorModel>;\n    /** @ignore */ protected readonly _tableviewEditorType: TableviewEditorTypeEnum;\n    /** @ignore */ protected readonly _tabs: Array<FieldTabGroupDescriptor<EditorModel>> = [];\n    /** @ignore */ protected readonly _groups: Array<FieldGroupDescriptor<EditorModel>> = [];\n    /** @ignore */ protected _fields: Array<AFieldDescriptor<any, EditorModel>> = [];\n    /** @ignore */ protected _currentTabGroup?: FieldTabGroupDescriptor<EditorModel>;\n    /** @ignore */ protected _currentGroup?: FieldGroupDescriptor<EditorModel>;\n\n    /** @ignore */ protected _disabled = false;\n\n    /** @ignore */ protected _isLocalized = false;\n    /** @ignore */ protected _localizationLocaleProperty?: string;\n    /** @ignore */ protected _localizationModel?: ModelDescriptor<any>;\n    /** @ignore */ protected _localizationLocalizationProperty?: string;\n\n    /** @ignore */ protected readonly _eventsSubject = new Subject<MngFormEvent<EditorModel>>();\n\n    /**\n     * Creates new instance of editor descriptor.\n     * @param model Model descriptor.\n     * @param tableviewEditorType Type of editor in tableview (add, edit, view or none).\n     */\n    protected constructor(model: ModelDescriptor<EditorModel>, tableviewEditorType = TableviewEditorTypeEnum.None) {\n        this._model = model;\n        this._tableviewEditorType = tableviewEditorType;\n    }\n\n    /**\n     * Model descriptor for editor.\n     */\n    public get model() {\n        return this._model;\n    }\n\n    /**\n     * Editor's tabs.\n     */\n    public get tabs() {\n        return this._tabs;\n    }\n\n    /**\n     * Editor's fields.\n     */\n    public get fields() {\n        return this._fields;\n    }\n\n    /**\n     * Type of editor for tableview.\n     */\n    public get tableviewEditorType() {\n        return this._tableviewEditorType;\n    }\n\n    /**\n     * If editor is disabled.\n     */\n    public get disabled() {\n        return this._disabled;\n    }\n\n    public get isLocalized() {\n        return this._isLocalized;\n    }\n\n    public get localizationLocaleProperty() {\n        return this._localizationLocaleProperty;\n    }\n\n    public get localizationLocalizationProperty() {\n        return this._localizationLocalizationProperty;\n    }\n\n    public get localizationModel() {\n        return this._localizationModel;\n    }\n\n    /**\n     * Creates new tab group. Next added fields are added to newly created tab group.\n     * @param name Name of the group.\n     * @param title Title key for the tab.\n     */\n    public createTabGroup(name: string, title?: string): FieldTabGroupDescriptor<EditorModel> {\n        const tabGroup = new FieldTabGroupDescriptor<EditorModel>(this, name);\n        if (!title) {\n            title = I18nUtils.Type.getTabKey(this.model.i18nBaseKey, name);\n        }\n        tabGroup.withTitle(title);\n        this.createTabGroupDescriptor(tabGroup);\n        return tabGroup;\n    }\n\n    /**\n     * Creates new field group. Next added fields are added to newly created field group.\n     * @param name Name of the group.\n     * @param title Title key for the group.\n     */\n    public createFieldGroup(name: string, title?: string | null): FieldGroupDescriptor<EditorModel> {\n        const fieldGroup = new FieldGroupDescriptor<EditorModel>(this, name);\n        if (title !== null) {\n            if (!title) {\n                title = I18nUtils.Type.getGroupKey(this.model.i18nBaseKey, name);\n            }\n            fieldGroup.withTitle(title);\n        }\n        this.createFieldGroupDescriptor(fieldGroup);\n        return fieldGroup;\n    }\n\n    /**\n     * Gets field by the model property name.\n     * @param property Model property name.\n     */\n    public getField(property: keyof EditorModel) {\n        return this.getFieldUnsafe(property as string);\n    }\n\n    /**\n     * Gets field by the model property name (UNSAFE).\n     * @param property Model property name.\n     */\n    public getFieldUnsafe(property: string): AFieldDescriptor<any, EditorModel> | null {\n        return this._fields.find(f => f.property === property) ?? null;\n    }\n\n    /**\n     * Removes field by the model property name.\n     * @param property Model property name.\n     */\n    public removeField(property: keyof EditorModel): void {\n        return this.removeFieldUnsafe(property as string);\n    }\n\n    /**\n     * Removes field by the model property name (UNSAFE).\n     * @param property Model property name.\n     */\n    public removeFieldUnsafe(property: string): void {\n        const fieldIdx = this._fields.findIndex(f => f.property === property);\n        if (fieldIdx < 0) {\n            throw new MngInternalError(`Field ${property} does not exist.`, {name: 'EditorDescriptorError'});\n        }\n        for (const group of this._groups) {\n            const groupFieldIdx = group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);\n            if (groupFieldIdx >= 0) {\n                group.fields.splice(groupFieldIdx, 1);\n                break;\n            }\n        }\n        this._fields.splice(fieldIdx, 1);\n    }\n\n    /**\n     * Adds field by the descriptor.\n     * @param field Field descriptor.\n     */\n    public addFieldDescriptor<FieldModel, FieldValue = FieldModel>(field: AFieldDescriptor<FieldModel, EditorModel, FieldValue>): this {\n        this.createDefaultGroup();\n        this._fields.push(field);\n        this._currentGroup?.addField(field);\n        return this;\n    }\n\n    /**\n     * Adds field by the model property name.\n     * @param property Model property name.\n     */\n    public addField<Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(property: Property) {\n        const field = new FieldInputDescriptor<EditorModel, FieldModel, FieldValue>(this, property as string);\n        this.addFieldDescriptor<FieldModel, FieldValue>(field);\n        return field;\n    }\n\n    /**\n     * Adds field by the model property name (UNSAFE). Property is not checked on editor model.\n     * Use {addField} for safe usage.\n     * @param property Model property name.\n     */\n    public addFieldUnsafe<FieldModel = FieldInputDescriptorType, FieldValue = FieldModel>(property: string) {\n        const field = new FieldInputDescriptor<EditorModel, FieldModel, FieldValue>(this, property);\n        this.addFieldDescriptor<FieldModel, FieldValue>(field);\n        return field;\n    }\n\n    public addFields(...properties: (keyof EditorModel)[]): this {\n        properties.forEach(p => this.addField(p));\n        return this;\n    }\n\n    public addFieldAction(actionName: string): FieldActionDescriptor<EditorModel> {\n        const field = new FieldActionDescriptor(this, actionName);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Adds lookup field.\n     * @param property Model property name.\n     * @param type Model's class type.\n     */\n    public addFieldLookup<K extends keyof EditorModel, FieldModel = NonNullable<EditorModel[K]>, FieldValue = EditorModel[K]>(property: K, type?: ClassType<FieldModel>) {\n        return this.addFieldLookupUnsafe<FieldModel, FieldValue>(property as string, type);\n    }\n\n    /**\n     * Adds lookup field (UNSAFE).\n     * @param property Model property name.\n     * @param type Model's class type.\n     */\n    public addFieldLookupUnsafe<FieldModel, FieldValue = FieldModel>(property: string, type?: ClassType<FieldModel>) {\n        const field = new FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue>(this, property, {\n            type: type\n        });\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public addFieldLookupWithPropertyAsValueUnsafe<FieldModel, FieldValue = Nullable<IdType>>(property: string, optionsValueProperty: string) {\n        const field = new FieldLookupDescriptor<FieldModel, EditorModel, undefined, FieldValue>(this, property, {\n            optionsValueProperty: optionsValueProperty\n        });\n        this.addFieldDescriptor<FieldModel, FieldValue>(field);\n        return field;\n    }\n\n    public addFieldLookupWithProvider<Service, Property extends keyof EditorModel, FieldModel = NonNullable<EditorModel[Property]>, FieldValue = EditorModel[Property]>(\n        property: Property,\n        provider: FieldLookupProviderType<FieldModel, Service>,\n        type?: ClassType<FieldModel>\n    ) {\n        return this.addFieldLookupWithProviderUnsafe<Service, FieldModel, FieldValue>(property as string, provider, type);\n    }\n\n    public addFieldLookupWithProviderUnsafe<Service, FieldModel, FieldValue = FieldModel>(\n        property: string,\n        provider: FieldLookupProviderType<FieldModel, Service>,\n        type?: ClassType<FieldModel>\n    ) {\n        const cfg = fieldLookupGetProviderCfgObj(provider);\n        const field = new FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>(this, property, {\n            type: type,\n            ...cfg\n        });\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public addFieldLookupEnum(property: keyof EditorModel, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue = false, optionsTitlePath?: string | null) {\n        return this.addFieldLookupEnumUnsafe(property as string, enumType, options, nameAsValue, optionsTitlePath);\n    }\n\n    /**\n     * Adds enum lookup field.\n     * @param property Model's property name.\n     * @param enumType Type of enum.\n     * @param options Provides subset of enum's available constants.\n     * @param nameAsValue If constant's name should be used as final value of the enum. Primarily, constant's value will be used.\n     * @param optionsTitlePath Title key path from where translations are provided. If null, the enum's values won't be translated.\n     */\n    public addFieldLookupEnumUnsafe(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue = false, optionsTitlePath?: string | null) {\n        const field = new FieldLookupEnumDescriptor<EditorModel>(this, property, enumType, options, nameAsValue, optionsTitlePath);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Adds table/details/add/edit field for one-to-many (1:n) relations.\n     * @param property Model's property name.\n     * @param tableviewDescriptor Tableview descriptor for related model.\n     */\n    public addFieldManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(\n        property: Property,\n        tableviewDescriptor: TableviewDescriptorInst<FieldModel>\n    ) {\n        return this.addFieldManyEditorUnsafe<FieldModel, FieldValue>(property as string, tableviewDescriptor);\n    }\n\n    /**\n     * Adds table/details/add/edit field for one-to-many (1:n) relations (UNSAFE).\n     * @param property Model's property name.\n     * @param tableviewDescriptor Tableview descriptor for related model.\n     */\n    public addFieldManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel>) {\n        const field = new FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>(this, property, tableviewDescriptor);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Adds tables for many-to-many (m:n) relations.\n     * @param property Model's property name.\n     * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.\n     * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.\n     */\n    public addFieldManyToManyEditor<Property extends keyof EditorModel, FieldModel = ArrayItemType<EditorModel[Property]>, FieldValue = EditorModel[Property]>(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>\n    ) {\n        return this.addFieldManyToManyEditorUnsafe<FieldModel, FieldValue>(property as string, mainTableDescriptor, lookupTableDescriptor);\n    }\n\n    /**\n     * Adds tables for many-to-many (m:n) relations (UNSAFE).\n     * @param property Model's property name.\n     * @param mainTableDescriptor Main table descriptor for displaying items added to main model's property.\n     * @param lookupTableDescriptor Lookup table descriptor for displaying items to be added to main model's property.\n     */\n    public addFieldManyToManyEditorUnsafe<FieldModel, FieldValue = FieldModel[]>(\n        property: string,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>\n    ) {\n        const field = new FieldManyToManyEditorDescriptor<FieldModel, EditorModel, undefined, FieldValue>(this, property, mainTableDescriptor, lookupTableDescriptor);\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    public addFieldManyToManyEditorWithProvider<\n        Property extends keyof EditorModel,\n        ServiceType,\n        FieldModel = ArrayItemType<EditorModel[Property]>,\n        FieldValue = EditorModel[Property]\n    >(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>\n    ) {\n        return this.addFieldManyToManyEditorWithProviderUnsafe<FieldModel, ServiceType, FieldValue>(\n            property as string,\n            mainTableDescriptor,\n            lookupTableDescriptor,\n            lookupDataProvider\n        );\n    }\n\n    public addFieldManyToManyEditorWithProviderUnsafe<FieldModel, ServiceType, FieldValue = FieldModel[]>(\n        property: string,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>\n    ): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue> {\n        const cfg = fieldManyToManyGetProviderCfgObj(lookupDataProvider);\n        const field = new FieldManyToManyEditorDescriptor<FieldModel, EditorModel, ServiceType, FieldValue>(this, property, mainTableDescriptor, lookupTableDescriptor, {\n            ...cfg\n        });\n        this.addFieldDescriptor(field);\n        return field;\n    }\n\n    /**\n     * Disables field on editor.\n     * @param disabled\n     */\n    public withDisabled(disabled = true): this {\n        this._disabled = disabled;\n        return this;\n    }\n\n    /**\n     * Adds group validator to editor.\n     * @param name Name of the validation.\n     * @param validator Field validator function.\n     * @param message Field validation message.\n     */\n    public addValidation(name: string, validator?: MngFieldValidator, message?: MngFieldValidationMessage) {\n        if (this._currentGroup) {\n            this._currentGroup.withValidation(name, validator, message);\n        }\n    }\n\n    /**\n     * Creates a copy of editor descriptor object.\n     */\n    public copy(): EditorDescriptorInst<EditorModel> {\n        const editor = new EditorDescriptorInst<EditorModel>(this.model.copy(), this.tableviewEditorType);\n        for (const tabGroup of this._tabs) {\n            editor.createTabGroupDescriptor(tabGroup.copy());\n        }\n        for (const tabGroup of editor._tabs) {\n            for (const fieldGroup of tabGroup.fields) {\n                editor._fields.push(...fieldGroup.fields);\n            }\n            editor._groups.push(...tabGroup.fields);\n        }\n        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];\n        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];\n        editor._disabled = this._disabled;\n        return editor;\n    }\n\n    /**\n     * Created group from field group descriptor.\n     * @param fieldGroup Field group descriptor.\n     * @internal\n     */\n    public createFieldGroupDescriptor(fieldGroup: FieldGroupDescriptor<EditorModel>): this {\n        this.createDefaultTabGroup();\n        this._currentGroup = fieldGroup;\n        this._groups.push(fieldGroup);\n        this._currentTabGroup?.addField(fieldGroup);\n        return this;\n    }\n\n    /**\n     * Creates tab group from tab group descriptor.\n     * @param tabGroup Tab group descriptor.\n     * @internal\n     */\n    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<EditorModel>): this {\n        this._currentTabGroup = tabGroup;\n        this._tabs.push(tabGroup);\n        return this;\n    }\n\n    /**\n     * Creates default field group.\n     * @internal\n     */\n    private createDefaultGroup() {\n        this.createDefaultTabGroup();\n        if (this._currentTabGroup?.fields.length === 0) {\n            this.createFieldGroup(EditorDescriptorInst.defaultGroupName, null);\n        }\n    }\n\n    /**\n     * Creates default tab group.\n     * @internal\n     */\n    private createDefaultTabGroup() {\n        if (this._tabs.length === 0) {\n            this.createTabGroup(EditorDescriptorInst.defaultGroupName, 'general.general');\n        }\n    }\n\n    /**\n     * Modifies selected field by field property. For enums use {withFieldModifiedEnum} instead.\n     * @param property Model's property name.\n     * @param fieldType new field type for selected field\n     * @param args additional parameters for field\n     */\n    public withFieldModifiedType(property: keyof EditorModel, fieldType: FieldInputTypeEnum, ...args: any[]): this {\n        return this.withFieldModifiedTypeUnsafe(property as string, fieldType, ...args);\n    }\n\n    public withFieldModifiedTypeUnsafe(property: string, fieldType: FieldInputTypeEnum, ...args: any[]): this {\n        if (!this.model.type) {\n            throw new MngInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model type is not defined.`);\n        }\n        const attribute = TableviewUtil.getAttributeDefMap(this.model.type).find(attribute => attribute.name === property);\n        if (attribute) {\n            attribute.fieldType = fieldType;\n            EditorDescriptorInst.upsertFieldFromAttributeDef(\n                this,\n                attribute,\n                this.fields.find(fi => fi.property === property),\n                ...args\n            );\n        }\n        return this;\n    }\n\n    /**\n     * Modifies selected field with enum type.\n     * @param property Model's property name.\n     * @param enumType type of enum for new field\n     * @param optionsTitlePath\n     * @param values\n     * @param nameAsValue\n     */\n    public withFieldModifiedEnum(property: keyof EditorModel, enumType?: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue = false): this {\n        return this.withFieldModifiedEnumUnsafe(property as string, enumType, optionsTitlePath, values, nameAsValue);\n    }\n\n    public withFieldModifiedEnumUnsafe(property: string, enumType?: EnumType, optionsTitlePath?: string | null, values?: Array<EnumConstantType>, nameAsValue = false): this {\n        if (!this.model.type) {\n            throw new MngInternalError(`withFieldModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);\n        }\n        const attribute = TableviewUtil.getAttributeDefMap(this.model.type).find(a => a.name === property);\n        if (attribute) {\n            attribute.fieldType = FieldInputTypeEnum.Radio;\n            const field = this.fields.find(f => f.property === property);\n            if (field && field instanceof FieldInputDescriptor) {\n                field.asRadioFromEnum(enumType ?? (TypeRegistry.get().findEnum(attribute.type) as EnumType), optionsTitlePath, values, nameAsValue);\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * Modifies selected field with lookup field.\n     * @param property Model's property name.\n     * @param lookupProvider provider to be added to field\n     * @param titleProperty\n     */\n    public withFieldModifiedLookupWithProvider<ServiceType, FieldModel>(\n        property: keyof EditorModel,\n        lookupProvider: ILookupDataProvider<FieldModel, ServiceType>,\n        titleProperty?: keyof FieldModel\n    ): this {\n        return this.withFieldModifiedLookupWithProviderUnsafe(property as string, lookupProvider, titleProperty as string);\n    }\n\n    public withFieldModifiedLookupWithProviderUnsafe<ServiceType, FieldModel>(\n        property: string,\n        lookupProvider: ILookupDataProvider<FieldModel, ServiceType>,\n        titleProperty?: string\n    ): this {\n        this.removeFieldUnsafe(property);\n        const field = this.addFieldLookupWithProviderUnsafe<ServiceType, FieldModel>(property, lookupProvider).asAutocomplete();\n\n        if (titleProperty) {\n            (field as FieldLookupDescriptor<any, any>).withOptionsLabelProperty(titleProperty);\n        }\n\n        return this;\n    }\n\n    /**\n     * This method takes care of displaying correct/localized data in the editor\n     * @param property property that tells us where on the model are localizations accessible\n     * @param model Model for localizations\n     * @param localeProperty property by which we find the locale\n     */\n    public localized<Property extends keyof EditorModel, LocalizationModel = ArrayItemType<EditorModel[Property]>>(\n        property: Property,\n        model: ModelDescriptor<LocalizationModel>,\n        localeProperty: keyof LocalizationModel\n    ): this {\n        return this.localizedUnsafe(property as string, model, localeProperty as string);\n    }\n\n    public localizedUnsafe<LocalizationType>(property: string, model: ModelDescriptor<LocalizationType>, localeProperty: string): this {\n        this._localizationLocalizationProperty = property as string;\n        this._localizationModel = model;\n        this._localizationLocaleProperty = localeProperty as string;\n        this._isLocalized = true;\n\n        return this;\n    }\n\n    public nextEvent(type: MngFormEventTypeEnum, cmpType: Type<any>, cmpInstance: any, data?: MngFieldEventData<EditorModel>) {\n        this._eventsSubject.next(new MngFormEvent(type, cmpType, cmpInstance, data));\n    }\n\n    public completeEvents() {\n        this._eventsSubject.complete();\n    }\n\n    public get events$() {\n        return this._eventsSubject.asObservable();\n    }\n\n    /**\n     * Generates field based on attribute definition, used for auto model\n     * @param descriptor Editor descriptor instance.\n     * @param attribute Attribute definition.\n     * @param field Optional, if defined will be replaced, otherwise new will be generated.\n     * @param args Optional additional arguments mapped to filed type. Arguments depend on possible arguments on fields.\n     * @internal\n     */\n    protected static upsertFieldFromAttributeDef<T>(\n        descriptor: EditorDescriptorInst<T>,\n        attribute: TableviewAttributeDef,\n        field?: AFieldDescriptor<any, T>,\n        ...args: any[]\n    ): AFieldDescriptor<any, T> {\n        if (field == null) {\n            field = descriptor.addFieldUnsafe(attribute.name);\n        }\n\n        if (field instanceof FieldInputDescriptor) {\n            if (attribute.enumType) {\n                return field.asRadioFromEnum(attribute.enumType);\n            } else {\n                return field.asType(attribute.fieldType ?? TableviewUtil.toFieldInputTypeFromColumnType(attribute.columnType, attribute.columnDisplayType), ...args);\n            }\n        }\n\n        return field;\n    }\n}\n\nexport class EditorDescriptor extends EditorDescriptorInst<any> {\n    protected constructor() {\n        super(ModelDescriptor.create());\n    }\n\n    public static create<EditorModel>(\n        idProperty: keyof EditorModel,\n        titleProperty: keyof EditorModel,\n        i18nBaseKey: string | ClassType<unknown>,\n        tableviewEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel> {\n        return new EditorDescriptorInst<EditorModel>(ModelDescriptor.create<EditorModel>(idProperty, titleProperty, i18nBaseKey), tableviewEditorType);\n    }\n\n    public static fromClass<EditorModel>(\n        type: ClassType<EditorModel>,\n        idProperty?: keyof EditorModel,\n        titleProperty?: keyof EditorModel,\n        i18nBaseKey?: ClassType<unknown> | string,\n        tableviewEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel> {\n        return new EditorDescriptorInst<EditorModel>(ModelDescriptor.fromClass(type, idProperty, titleProperty, i18nBaseKey), tableviewEditorType);\n    }\n\n    public static fromModel<EditorModel>(model: ModelDescriptor<EditorModel>, tableviewEditorType = TableviewEditorTypeEnum.None): EditorDescriptorInst<EditorModel> {\n        return new EditorDescriptorInst<EditorModel>(model, tableviewEditorType);\n    }\n\n    /**\n     * Creates editor descriptor automatically based on openapi model's attributes definition which is automatically extracted. All fields will be included.\n     * @param type Model's class.\n     * @param idProperty Id property representing model (optional).\n     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.\n     * @param tableEditorType Type of editor in tableview (add, edit, view or none).\n     */\n    public static fromClassWithAutoAttrsDef<EditorModel>(\n        type: ClassType<EditorModel>,\n        idProperty?: keyof EditorModel,\n        titleProperty?: keyof EditorModel,\n        tableEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel> {\n        return EditorDescriptor.fromClassWithCustomAttrsDef(type, TableviewUtil.getAttributeDefMap(type), idProperty, titleProperty, tableEditorType);\n    }\n\n    /**\n     * Creates editor descriptor automatically based on openapi model's attributes definition provided in parameters. Only fields for provided attributes will be included.\n     * @param type Model's class.\n     * @param attributes List of attribute definitions from which fields should be created.\n     * @param idProperty Id property representing model (optional).\n     * @param titleProperty Title property representing model (optional). If not provided, it will be automatically chosen.\n     * @param tableEditorType Type of editor in tableview (add, edit, view or none).\n     */\n    public static fromClassWithCustomAttrsDef<EditorModel>(\n        type: ClassType<EditorModel>,\n        attributes: TableviewAttributeDef[],\n        idProperty?: keyof EditorModel,\n        titleProperty?: keyof EditorModel,\n        tableEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel> {\n        const descriptor = EditorDescriptor.fromClass(type, idProperty, titleProperty, undefined, tableEditorType);\n\n        attributes\n            .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))\n            .forEach(attr =>\n                EditorDescriptorInst.upsertFieldFromAttributeDef(\n                    descriptor,\n                    attr,\n                    descriptor.fields.find(col => col.property === attr.name)\n                )\n            );\n        return descriptor;\n    }\n}\n"]}