@mediusinc/mng-commons 0.12.2 → 0.12.3-rc.1

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

@@ -1,147 +1,285 @@
-import { I18nUtils } from '../utils';
-import { AFieldDescriptor, FieldGroupDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, FieldTabGroupDescriptor, ModelDescriptor } from './';
-import { TableviewTypeEnum } from './types';
-export class EditorDescriptor {
-    constructor(modelType, idProperty, titleProperty, tableviewEditorType = TableviewTypeEnum.None) {
-        this._tabs = [];
-        this._groups = [];
-        this._fields = [];
-        this._disabled = false;
-        this._model = new ModelDescriptor(modelType, idProperty, titleProperty);
-        this._tableviewEditorType = tableviewEditorType;
-    }
-    get model() {
-        return this._model;
-    }
-    get tabs() {
-        return this._tabs;
-    }
-    get fields() {
-        return this._fields;
-    }
-    get tableviewEditorType() {
-        return this._disabled;
-    }
-    get disabled() {
-        return this._disabled;
-    }
-    createTabGroup(name, title) {
-        const tabGroup = new FieldTabGroupDescriptor(this, name);
-        if (!title) {
-            title = I18nUtils.Type.getTabKey(this.model.typeName, name);
-        }
-        tabGroup.withTitle(title);
-        this.createTabGroupDescriptor(tabGroup);
-        return tabGroup;
-    }
-    createFieldGroup(name, title) {
-        const fieldGroup = new FieldGroupDescriptor(this, name);
-        if (title !== null) {
-            if (!title) {
-                title = I18nUtils.Type.getGroupKey(this.model.typeName, name);
-            }
-            fieldGroup.withTitle(title);
-        }
-        this.createFieldGroupDescriptor(fieldGroup);
-        return fieldGroup;
-    }
-    addFieldDescriptor(field) {
-        this.createDefaultGroup();
-        this._fields.push(field);
-        this._currentGroup?.addField(field);
-        return this;
-    }
-    addField(property) {
-        const field = new FieldInputDescriptor(this, property);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    removeField(property) {
-        const fieldIdx = this._fields.findIndex(f => f.property === property);
-        if (fieldIdx < 0) {
-            throw new Error(`Field ${property} does not exist.`);
-        }
-        const field = this._fields[fieldIdx];
-        if (field.group) {
-            const groupFieldIdx = field.group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);
-            if (groupFieldIdx >= 0) {
-                field.group.fields.splice(groupFieldIdx, 1);
-            }
-        }
-        this._fields.splice(fieldIdx, 1);
-        return this;
-    }
-    getField(property) {
-        return this._fields.find(f => f.property === property) ?? null;
-    }
-    addFieldLookup(property, modelType) {
-        const field = new FieldLookupDescriptor(this, property, modelType);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    addFieldLookupEnum(property, enumType, options, nameAsValue = false, optionsTitlePath) {
-        const field = new FieldLookupEnumDescriptor(this, property, enumType, options, nameAsValue, optionsTitlePath);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    addFieldManyEditor(property, tableviewDescriptor) {
-        const field = new FieldManyEditorDescriptor(this, property, tableviewDescriptor);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor) {
-        const field = new FieldManyToManyEditorDescriptor(this, property, mainTableDescriptor, lookupTableDescriptor);
-        this.addFieldDescriptor(field);
-        return field;
-    }
-    withDisabled(disabled = true) {
-        this._disabled = disabled;
-        return this;
-    }
-    addValidation(name, validator, message) {
-        if (this._currentGroup) {
-            this._currentGroup.withValidation(name, validator, message);
-        }
-    }
-    copy() {
-        const editor = new EditorDescriptor(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);
-        for (const tabGroup of this._tabs) {
-            editor.createTabGroupDescriptor(tabGroup.copy());
-        }
-        for (const tabGroup of editor._tabs) {
-            for (const fieldGroup of tabGroup.fields) {
-                editor._fields.push(...fieldGroup.fields);
-            }
-            editor._groups.push(...tabGroup.fields);
-        }
-        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];
-        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];
-        editor._disabled = this._disabled;
-        return editor;
-    }
-    createFieldGroupDescriptor(fieldGroup) {
-        this.createDefaultTabGroup();
-        this._currentGroup = fieldGroup;
-        this._groups.push(fieldGroup);
-        this._currentTabGroup?.addField(fieldGroup);
-        return this;
-    }
-    createTabGroupDescriptor(tabGroup) {
-        this._currentTabGroup = tabGroup;
-        this._tabs.push(tabGroup);
-        return this;
-    }
-    createDefaultGroup() {
-        this.createDefaultTabGroup();
-        if (this._currentTabGroup?.fields.length === 0) {
-            this.createFieldGroup(EditorDescriptor.defaultGroupName, null);
-        }
-    }
-    createDefaultTabGroup() {
-        if (this._tabs.length === 0) {
-            this.createTabGroup(EditorDescriptor.defaultGroupName, 'general.general');
-        }
-    }
-}
-EditorDescriptor.defaultGroupName = '_default';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.descriptor.js","sourceRoot":"","sources":["../../../../src/lib/descriptors/editor.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {ClassType, EnumConstantType, EnumType, MngFieldValidationMessage, MngFieldValidator} from '../types';\nimport {I18nUtils} from '../utils';\nimport {\n    AFieldDescriptor,\n    FieldGroupDescriptor,\n    FieldInputDescriptor,\n    FieldLookupDescriptor,\n    FieldLookupEnumDescriptor,\n    FieldManyEditorDescriptor,\n    FieldManyToManyEditorDescriptor,\n    FieldTabGroupDescriptor,\n    ModelDescriptor,\n    TableDescriptor,\n    TableviewDescriptor\n} from './';\nimport {TableviewTypeEnum} from './types';\n\nexport class EditorDescriptor<T> {\n    public static readonly defaultGroupName = '_default';\n\n    private readonly _model: ModelDescriptor<T>;\n    private readonly _tableviewEditorType: TableviewTypeEnum;\n    private readonly _tabs: Array<FieldTabGroupDescriptor<T>> = [];\n    private readonly _groups: Array<FieldGroupDescriptor<T>> = [];\n    private readonly _fields: Array<AFieldDescriptor<any, T>> = [];\n    private _currentTabGroup?: FieldTabGroupDescriptor<T>;\n    private _currentGroup?: FieldGroupDescriptor<T>;\n\n    private _disabled = false;\n\n    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableviewEditorType = TableviewTypeEnum.None) {\n        this._model = new ModelDescriptor<T>(modelType, idProperty, titleProperty);\n        this._tableviewEditorType = tableviewEditorType;\n    }\n\n    public get model() {\n        return this._model;\n    }\n\n    public get tabs() {\n        return this._tabs;\n    }\n\n    public get fields() {\n        return this._fields;\n    }\n\n    public get tableviewEditorType() {\n        return this._disabled;\n    }\n\n    public get disabled() {\n        return this._disabled;\n    }\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.typeName, name);\n        }\n        tabGroup.withTitle(title);\n        this.createTabGroupDescriptor(tabGroup);\n        return tabGroup;\n    }\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.typeName, name);\n            }\n            fieldGroup.withTitle(title);\n        }\n        this.createFieldGroupDescriptor(fieldGroup);\n        return fieldGroup;\n    }\n\n    public addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this {\n        this.createDefaultGroup();\n        this._fields.push(field);\n        this._currentGroup?.addField(field);\n        return this;\n    }\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    public removeField(property: string): this {\n        const fieldIdx = this._fields.findIndex(f => f.property === property);\n        if (fieldIdx < 0) {\n            throw new Error(`Field ${property} does not exist.`);\n        }\n        const field = this._fields[fieldIdx];\n        if (field.group) {\n            const groupFieldIdx = field.group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);\n            if (groupFieldIdx >= 0) {\n                field.group.fields.splice(groupFieldIdx, 1);\n            }\n        }\n        this._fields.splice(fieldIdx, 1);\n        return this;\n    }\n\n    public getField(property: string): AFieldDescriptor<any, T> | null {\n        return this._fields.find(f => f.property === property) ?? null;\n    }\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    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    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    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    public withDisabled(disabled = true): this {\n        this._disabled = disabled;\n        return this;\n    }\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    public copy(): EditorDescriptor<T> {\n        const editor = new EditorDescriptor<T>(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);\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    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    private createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<T>): this {\n        this._currentTabGroup = tabGroup;\n        this._tabs.push(tabGroup);\n        return this;\n    }\n\n    private createDefaultGroup() {\n        this.createDefaultTabGroup();\n        if (this._currentTabGroup?.fields.length === 0) {\n            this.createFieldGroup(EditorDescriptor.defaultGroupName, null);\n        }\n    }\n\n    private createDefaultTabGroup() {\n        if (this._tabs.length === 0) {\n            this.createTabGroup(EditorDescriptor.defaultGroupName, 'general.general');\n        }\n    }\n}\n"]}
+import { ObjectSerializer } from '../api/utils';
+import { FieldUtil, I18nUtils } from '../utils';
+import { TableviewUtil } from '../utils/tableview.util';
+import { AFieldDescriptor, FieldGroupDescriptor, FieldInputDescriptor, FieldLookupDescriptor, FieldLookupEnumDescriptor, FieldManyEditorDescriptor, FieldManyToManyEditorDescriptor, FieldTabGroupDescriptor, ModelDescriptor } from './';
+import { FieldInputTypeEnum, TableviewTypeEnum } from './types';
+export class EditorDescriptor {
+    constructor(modelType, idProperty, titleProperty, tableviewEditorType = TableviewTypeEnum.None) {
+        this._tabs = [];
+        this._groups = [];
+        this._fields = [];
+        this._disabled = false;
+        this._model = new ModelDescriptor(modelType, idProperty, titleProperty);
+        this._tableviewEditorType = tableviewEditorType;
+    }
+    get model() {
+        return this._model;
+    }
+    get tabs() {
+        return this._tabs;
+    }
+    get fields() {
+        return this._fields;
+    }
+    get tableviewEditorType() {
+        return this._disabled;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    createTabGroup(name, title) {
+        const tabGroup = new FieldTabGroupDescriptor(this, name);
+        if (!title) {
+            title = I18nUtils.Type.getTabKey(this.model.typeName, name);
+        }
+        tabGroup.withTitle(title);
+        this.createTabGroupDescriptor(tabGroup);
+        return tabGroup;
+    }
+    createFieldGroup(name, title) {
+        const fieldGroup = new FieldGroupDescriptor(this, name);
+        if (title !== null) {
+            if (!title) {
+                title = I18nUtils.Type.getGroupKey(this.model.typeName, name);
+            }
+            fieldGroup.withTitle(title);
+        }
+        this.createFieldGroupDescriptor(fieldGroup);
+        return fieldGroup;
+    }
+    addFieldDescriptor(field) {
+        this.createDefaultGroup();
+        this._fields.push(field);
+        this._currentGroup?.addField(field);
+        return this;
+    }
+    addField(property) {
+        const field = new FieldInputDescriptor(this, property);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    removeField(property) {
+        const fieldIdx = this._fields.findIndex(f => f.property === property);
+        if (fieldIdx < 0) {
+            throw new Error(`Field ${property} does not exist.`);
+        }
+        for (const group of this._groups) {
+            const groupFieldIdx = group.fields.findIndex(f => f instanceof AFieldDescriptor && f.property === property);
+            if (groupFieldIdx >= 0) {
+                group.fields.splice(groupFieldIdx, 1);
+                break;
+            }
+        }
+        this._fields.splice(fieldIdx, 1);
+    }
+    getField(property) {
+        return this._fields.find(f => f.property === property) ?? null;
+    }
+    addFieldLookup(property, modelType) {
+        const field = new FieldLookupDescriptor(this, property, modelType);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldLookupEnum(property, enumType, options, nameAsValue = false, optionsTitlePath) {
+        const field = new FieldLookupEnumDescriptor(this, property, enumType, options, nameAsValue, optionsTitlePath);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldManyEditor(property, tableviewDescriptor) {
+        const field = new FieldManyEditorDescriptor(this, property, tableviewDescriptor);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    addFieldManyToManyEditor(property, mainTableDescriptor, lookupTableDescriptor) {
+        const field = new FieldManyToManyEditorDescriptor(this, property, mainTableDescriptor, lookupTableDescriptor);
+        this.addFieldDescriptor(field);
+        return field;
+    }
+    withDisabled(disabled = true) {
+        this._disabled = disabled;
+        return this;
+    }
+    addValidation(name, validator, message) {
+        if (this._currentGroup) {
+            this._currentGroup.withValidation(name, validator, message);
+        }
+    }
+    copy() {
+        const editor = new EditorDescriptor(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);
+        for (const tabGroup of this._tabs) {
+            editor.createTabGroupDescriptor(tabGroup.copy());
+        }
+        for (const tabGroup of editor._tabs) {
+            for (const fieldGroup of tabGroup.fields) {
+                editor._fields.push(...fieldGroup.fields);
+            }
+            editor._groups.push(...tabGroup.fields);
+        }
+        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];
+        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];
+        editor._disabled = this._disabled;
+        return editor;
+    }
+    createFieldGroupDescriptor(fieldGroup) {
+        this.createDefaultTabGroup();
+        this._currentGroup = fieldGroup;
+        this._groups.push(fieldGroup);
+        this._currentTabGroup?.addField(fieldGroup);
+        return this;
+    }
+    createTabGroupDescriptor(tabGroup) {
+        this._currentTabGroup = tabGroup;
+        this._tabs.push(tabGroup);
+        return this;
+    }
+    createDefaultGroup() {
+        this.createDefaultTabGroup();
+        if (this._currentTabGroup?.fields.length === 0) {
+            this.createFieldGroup(EditorDescriptor.defaultGroupName, null);
+        }
+    }
+    createDefaultTabGroup() {
+        if (this._tabs.length === 0) {
+            this.createTabGroup(EditorDescriptor.defaultGroupName, 'general.general');
+        }
+    }
+}
+EditorDescriptor.defaultGroupName = '_default';
+export class EditorAutoDescriptor extends EditorDescriptor {
+    constructor(modelType, attributes, idProperty, titleProperty, tableviewEditorType = TableviewTypeEnum.None) {
+        super(modelType, idProperty, titleProperty, tableviewEditorType);
+        this._attributes = attributes;
+        if (tableviewEditorType === TableviewTypeEnum.View) {
+            super.withDisabled();
+        }
+    }
+    /**
+     * creates editor with all attributes defined in model type
+     * @param modelType
+     * @param idProperty
+     * @param titleProperty
+     * @param tableEditorType
+     */
+    static generateFullFrom(modelType, idProperty, titleProperty, tableEditorType = TableviewTypeEnum.None) {
+        const descriptor = new EditorAutoDescriptor(modelType, TableviewUtil.getAttributeDefMap(modelType), idProperty, titleProperty, tableEditorType);
+        descriptor._attributes
+            .filter(a => !a.type.includes('Set') && !a.type.includes('Array')) //excludes many to many and one to many fields
+            .forEach(a => descriptor.generateField(a));
+        return descriptor;
+    }
+    /**
+     * creates empty editor wrapper
+     * @param modelType
+     * @param tableviewEditorType
+     * @param idProperty
+     * @param titleProperty
+     */
+    static generateFrom(modelType, tableviewEditorType = TableviewTypeEnum.None, idProperty, titleProperty) {
+        return new EditorAutoDescriptor(modelType, TableviewUtil.getAttributeDefMap(modelType), idProperty, titleProperty, tableviewEditorType);
+    }
+    /**
+     * add field defined in attributes
+     * use with customBuild()
+     * @param attributes fields to be added
+     */
+    withFields(attributes) {
+        attributes.forEach(a => this.generateField(a, super.fields.find(col => col.property === a.name)));
+        return this;
+    }
+    /**
+     * modifies field properties
+     * @param property field name to be modified
+     * @param args additional parameters
+     */
+    withModifiedProperty(property, ...args) {
+        const attribute = this._attributes.find(a => a.name === property);
+        if (attribute) {
+            this.generateField(attribute, this.fields.find(f => f.property === property), ...args);
+        }
+        return this;
+    }
+    /**
+     * modifies field type
+     * @param property field name to be modified
+     * @param fieldType
+     */
+    withModifiedType(property, fieldType) {
+        const attribute = this._attributes.find(attribute => attribute.name === property);
+        if (attribute) {
+            attribute.fieldType = fieldType;
+            this.generateField(attribute, super.fields.find(fi => fi.property === property));
+        }
+        return this;
+    }
+    /**
+     * modifies field type to enum
+     * @param property field name to be modified
+     * @param enumType
+     */
+    withCustomEnumType(property, enumType) {
+        const attribute = this._attributes.find(a => a.name === property);
+        if (attribute) {
+            attribute.fieldType = FieldInputTypeEnum.Radio;
+            const field = super.fields.find(f => f.property === property);
+            if (field && field instanceof FieldInputDescriptor) {
+                field.asRadioFromEnum(enumType ?? ObjectSerializer.get().findEnum(attribute.type));
+            }
+        }
+        return this;
+    }
+    /**
+     * adds field with class lookup
+     * @param property field name to be modified
+     * @param modelType
+     * @param lookupProvider
+     * @param titleProperty
+     */
+    withClassLookupProvider(property, modelType, lookupProvider, titleProperty) {
+        super.removeField(property);
+        const field = super.addFieldLookup(property, modelType).asAutocomplete().withLookupDataProvider(lookupProvider);
+        if (titleProperty) {
+            field.withItemsLabelProperty(titleProperty);
+        }
+        return this;
+    }
+    /**
+     * creates deep copy
+     */
+    copy() {
+        const editor = new EditorAutoDescriptor(this.model.type, this._attributes, this.model.idPropertyName, this.model.titlePropertyName);
+        for (const tabGroup of this._tabs) {
+            editor.createTabGroupDescriptor(tabGroup.copy());
+        }
+        for (const tabGroup of editor._tabs) {
+            for (const fieldGroup of tabGroup.fields) {
+                editor._fields.push(...fieldGroup.fields);
+            }
+            editor._groups.push(...tabGroup.fields);
+        }
+        editor._currentTabGroup = editor._tabs[editor._tabs.length - 1];
+        editor._currentGroup = editor._currentTabGroup.fields[editor._currentTabGroup.fields.length - 1];
+        editor._disabled = this._disabled;
+        return editor;
+    }
+    /**
+     * generates field
+     * @param attribute
+     * @param field
+     * @param args
+     */
+    generateField(attribute, field, ...args) {
+        if (field == null) {
+            field = super.addField(attribute.name);
+        }
+        if (field instanceof FieldInputDescriptor) {
+            if (attribute.enumType) {
+                return field.asRadioFromEnum(attribute.enumType);
+            }
+            else {
+                return field.asType(attribute.fieldType ?? FieldUtil.columnTypeToFieldType(attribute.columnType), ...args);
+            }
+        }
+        return field;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.descriptor.js","sourceRoot":"","sources":["../../../../src/lib/descriptors/editor.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {ObjectSerializer} from '../api/utils';\nimport {ILookupDataProvider} from '../data-providers';\nimport {ClassType, EnumConstantType, EnumType, MngFieldValidationMessage, MngFieldValidator} from '../types';\nimport {FieldUtil, I18nUtils} from '../utils';\nimport {TableviewUtil} from '../utils/tableview.util';\nimport {\n    AFieldDescriptor,\n    FieldGroupDescriptor,\n    FieldInputDescriptor,\n    FieldLookupDescriptor,\n    FieldLookupEnumDescriptor,\n    FieldManyEditorDescriptor,\n    FieldManyToManyEditorDescriptor,\n    FieldTabGroupDescriptor,\n    ModelDescriptor,\n    TableDescriptor,\n    TableviewDescriptor\n} from './';\nimport {FieldInputTypeEnum, TableviewTypeEnum} from './types';\nimport {TableviewAttributeDef} from './types/tableview-attr.model';\n\nexport class EditorDescriptor<T> {\n    public static readonly defaultGroupName = '_default';\n\n    protected readonly _model: ModelDescriptor<T>;\n    protected readonly _tableviewEditorType: TableviewTypeEnum;\n    protected readonly _tabs: Array<FieldTabGroupDescriptor<T>> = [];\n    protected readonly _groups: Array<FieldGroupDescriptor<T>> = [];\n    protected _fields: Array<AFieldDescriptor<any, T>> = [];\n    protected _currentTabGroup?: FieldTabGroupDescriptor<T>;\n    protected _currentGroup?: FieldGroupDescriptor<T>;\n\n    protected _disabled = false;\n\n    constructor(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableviewEditorType = TableviewTypeEnum.None) {\n        this._model = new ModelDescriptor<T>(modelType, idProperty, titleProperty);\n        this._tableviewEditorType = tableviewEditorType;\n    }\n\n    public get model() {\n        return this._model;\n    }\n\n    public get tabs() {\n        return this._tabs;\n    }\n\n    public get fields() {\n        return this._fields;\n    }\n\n    public get tableviewEditorType() {\n        return this._disabled;\n    }\n\n    public get disabled() {\n        return this._disabled;\n    }\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.typeName, name);\n        }\n        tabGroup.withTitle(title);\n        this.createTabGroupDescriptor(tabGroup);\n        return tabGroup;\n    }\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.typeName, name);\n            }\n            fieldGroup.withTitle(title);\n        }\n        this.createFieldGroupDescriptor(fieldGroup);\n        return fieldGroup;\n    }\n\n    public addFieldDescriptor<FT>(field: AFieldDescriptor<FT, T>): this {\n        this.createDefaultGroup();\n        this._fields.push(field);\n        this._currentGroup?.addField(field);\n        return this;\n    }\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    public removeField(property: string): void {\n        const fieldIdx = this._fields.findIndex(f => f.property === property);\n        if (fieldIdx < 0) {\n            throw new Error(`Field ${property} does not exist.`);\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    public getField(property: string): AFieldDescriptor<any, T> | null {\n        return this._fields.find(f => f.property === property) ?? null;\n    }\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    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    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    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    public withDisabled(disabled = true): this {\n        this._disabled = disabled;\n        return this;\n    }\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    public copy(): EditorDescriptor<T> {\n        const editor = new EditorDescriptor<T>(this.model.type, this.model.idPropertyName, this.model.titlePropertyName);\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    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    protected createTabGroupDescriptor(tabGroup: FieldTabGroupDescriptor<T>): this {\n        this._currentTabGroup = tabGroup;\n        this._tabs.push(tabGroup);\n        return this;\n    }\n\n    private createDefaultGroup() {\n        this.createDefaultTabGroup();\n        if (this._currentTabGroup?.fields.length === 0) {\n            this.createFieldGroup(EditorDescriptor.defaultGroupName, null);\n        }\n    }\n\n    private createDefaultTabGroup() {\n        if (this._tabs.length === 0) {\n            this.createTabGroup(EditorDescriptor.defaultGroupName, 'general.general');\n        }\n    }\n}\n\nexport class EditorAutoDescriptor<T> extends EditorDescriptor<T> {\n    private _attributes: TableviewAttributeDef[];\n\n    private constructor(modelType: ClassType<T>, attributes: TableviewAttributeDef[], idProperty?: string, titleProperty?: string, tableviewEditorType = TableviewTypeEnum.None) {\n        super(modelType, idProperty, titleProperty, tableviewEditorType);\n        this._attributes = attributes;\n        if (tableviewEditorType === TableviewTypeEnum.View) {\n            super.withDisabled();\n        }\n    }\n\n    /**\n     * creates editor with all attributes defined in model type\n     * @param modelType\n     * @param idProperty\n     * @param titleProperty\n     * @param tableEditorType\n     */\n    public static generateFullFrom<T>(modelType: ClassType<T>, idProperty?: string, titleProperty?: string, tableEditorType = TableviewTypeEnum.None): EditorAutoDescriptor<T> {\n        const descriptor = new EditorAutoDescriptor(modelType, TableviewUtil.getAttributeDefMap(modelType), idProperty, titleProperty, tableEditorType);\n        descriptor._attributes\n            .filter(a => !a.type.includes('Set') && !a.type.includes('Array')) //excludes many to many and one to many fields\n            .forEach(a => descriptor.generateField(a));\n        return descriptor;\n    }\n\n    /**\n     * creates empty editor wrapper\n     * @param modelType\n     * @param tableviewEditorType\n     * @param idProperty\n     * @param titleProperty\n     */\n    public static generateFrom<T>(modelType: ClassType<T>, tableviewEditorType = TableviewTypeEnum.None, idProperty?: string, titleProperty?: string): EditorAutoDescriptor<T> {\n        return new EditorAutoDescriptor(modelType, TableviewUtil.getAttributeDefMap(modelType), idProperty, titleProperty, tableviewEditorType);\n    }\n\n    /**\n     * add field defined in attributes\n     * use with customBuild()\n     * @param attributes fields to be added\n     */\n    public withFields(attributes: TableviewAttributeDef[]): this {\n        attributes.forEach(a =>\n            this.generateField(\n                a,\n                super.fields.find(col => col.property === a.name)\n            )\n        );\n        return this;\n    }\n\n    /**\n     * modifies field properties\n     * @param property field name to be modified\n     * @param args additional parameters\n     */\n    public withModifiedProperty(property: string, ...args: any[]): this {\n        const attribute = this._attributes.find(a => a.name === property);\n        if (attribute) {\n            this.generateField(\n                attribute,\n                this.fields.find(f => f.property === property),\n                ...args\n            );\n        }\n        return this;\n    }\n\n    /**\n     * modifies field type\n     * @param property field name to be modified\n     * @param fieldType\n     */\n    public withModifiedType(property: string, fieldType: FieldInputTypeEnum): this {\n        const attribute = this._attributes.find(attribute => attribute.name === property);\n        if (attribute) {\n            attribute.fieldType = fieldType;\n            this.generateField(\n                attribute,\n                super.fields.find(fi => fi.property === property)\n            );\n        }\n        return this;\n    }\n\n    /**\n     * modifies field type to enum\n     * @param property field name to be modified\n     * @param enumType\n     */\n    public withCustomEnumType(property: string, enumType?: EnumType): this {\n        const attribute = this._attributes.find(a => a.name === property);\n        if (attribute) {\n            attribute.fieldType = FieldInputTypeEnum.Radio;\n            const field = super.fields.find(f => f.property === property);\n            if (field && field instanceof FieldInputDescriptor) {\n                field.asRadioFromEnum(enumType ?? (ObjectSerializer.get().findEnum(attribute.type) as EnumType));\n            }\n        }\n\n        return this;\n    }\n\n    /**\n     * adds field with class lookup\n     * @param property field name to be modified\n     * @param modelType\n     * @param lookupProvider\n     * @param titleProperty\n     */\n    public withClassLookupProvider<MT>(property: string, modelType: ClassType<MT>, lookupProvider: ILookupDataProvider<any, any>, titleProperty?: string): this {\n        super.removeField(property);\n        const field = super.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     * creates deep copy\n     */\n    public override copy(): EditorAutoDescriptor<T> {\n        const editor = new EditorAutoDescriptor<T>(this.model.type, this._attributes, this.model.idPropertyName, this.model.titlePropertyName);\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     * generates field\n     * @param attribute\n     * @param field\n     * @param args\n     */\n    private generateField(attribute: TableviewAttributeDef, field?: AFieldDescriptor<any, T>, ...args: any[]): AFieldDescriptor<any, T> {\n        if (field == null) {\n            field = super.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 ?? FieldUtil.columnTypeToFieldType(attribute.columnType), ...args);\n            }\n        }\n\n        return field;\n    }\n}\n"]}

package/esm2020/lib/descriptors/field-validation.descriptor.mjs

@@ -1,21 +1,21 @@
-export class FieldValidationDescriptor {
-    constructor(name, validator, message, options) {
-        this._name = name;
-        this._validator = validator;
-        this._message = message;
-        this._options = options;
-    }
-    get name() {
-        return this._name;
-    }
-    get validator() {
-        return this._validator;
-    }
-    get message() {
-        return this._message;
-    }
-    get options() {
-        return this._options;
-    }
-}
+export class FieldValidationDescriptor {
+    constructor(name, validator, message, options) {
+        this._name = name;
+        this._validator = validator;
+        this._message = message;
+        this._options = options;
+    }
+    get name() {
+        return this._name;
+    }
+    get validator() {
+        return this._validator;
+    }
+    get message() {
+        return this._message;
+    }
+    get options() {
+        return this._options;
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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