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

package/esm2022/lib/descriptors/editor/field-lookup.descriptor.mjs

@@ -0,0 +1,211 @@
+import { of } from 'rxjs';
+import { LookupDataProvider } from '../../data-providers';
+import { DecoratorMetadataUtil, EnumUtil, ModelUtil } from '../../utils';
+import { FieldLookupTypeEnum } from '../types';
+import { AFieldDescriptor } from './field-base.descriptor';
+export const fieldLookupGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+// TODO: Generiki na daljša in jasna poimenovanja (kaj predstavlja)
+export class FieldLookupDescriptor extends AFieldDescriptor {
+    constructor(editor, property, cfg) {
+        super(editor, property);
+        this._lookupType = FieldLookupTypeEnum.Dropdown;
+        this._optionsLabelTranslate = false;
+        this._dropdownClassName = 'mng-filter-lookup-dropdown';
+        if (cfg?.dataProvider) {
+            this._dataProvider = cfg.dataProvider;
+        }
+        else {
+            this._dataProvider = LookupDataProvider.fromAnyParam(cfg?.type, cfg?.serviceType);
+        }
+        this._optionsValueProperty = cfg?.optionsValueProperty;
+        ModelUtil.trySetLookupItemsProperties(this);
+    }
+    get lookupType() {
+        return this._lookupType;
+    }
+    get optionsLabelProperty() {
+        return this._optionsLabelProperty;
+    }
+    get optionsLabelTranslate() {
+        return this._optionsLabelTranslate;
+    }
+    get optionsValueProperty() {
+        return this._optionsValueProperty;
+    }
+    get optionsDisabledProperty() {
+        return this._optionsDisabledProperty;
+    }
+    get optionsTrackProperty() {
+        return this._optionsTrackProperty;
+    }
+    get dataProvider() {
+        return this._dataProvider;
+    }
+    get autocompleteOpenOnFocus() {
+        return this._autocompleteOpenOnFocus;
+    }
+    get autocompleteInlineSearch() {
+        return this._autocompleteInlineSearch;
+    }
+    get autocompleteAutoClear() {
+        return this._autocompleteAutoClear;
+    }
+    get autocompleteSelectFirst() {
+        return this._autocompleteSelectFirst;
+    }
+    get dropdownClassName() {
+        return this._dropdownClassName;
+    }
+    get dialogTableDescriptor() {
+        return this._dialogTableDescriptor;
+    }
+    get dialogTableDataProvider() {
+        return this._dialogTableDataProvider;
+    }
+    get customComponentName() {
+        return this._customComponentName;
+    }
+    withOptionsLabelProperty(property, translate = false) {
+        return this.withOptionsLabelPropertyUnsafe(property, translate);
+    }
+    withOptionsLabelPropertyUnsafe(property, translate = false) {
+        this._optionsLabelProperty = property;
+        this._optionsLabelTranslate = translate;
+        return this;
+    }
+    withOptionsDisabledProperty(property) {
+        return this.withOptionsDisabledPropertyUnsafe(property);
+    }
+    withOptionsDisabledPropertyUnsafe(property) {
+        this._optionsDisabledProperty = property;
+        return this;
+    }
+    withOptionsTrackProperty(property) {
+        return this.withOptionsTrackPropertyUnsafe(property);
+    }
+    withOptionsTrackPropertyUnsafe(property) {
+        if (this._optionsValueProperty) {
+            return this;
+        }
+        this._optionsTrackProperty = property;
+        return this;
+    }
+    withLookup(lookup) {
+        this._dataProvider.withLookup(lookup);
+        return this;
+    }
+    withConfig(config) {
+        return super.withConfig(config);
+    }
+    asAutocomplete(opts) {
+        this._lookupType = FieldLookupTypeEnum.Autocomplete;
+        this._autocompleteAutoClear = opts?.autoClear;
+        this._autocompleteSelectFirst = opts?.selectFirst;
+        this._autocompleteOpenOnFocus = opts?.openOnFocus;
+        this._autocompleteInlineSearch = opts?.inlineSearch;
+        return this;
+    }
+    asDialog(lookupTableDescriptor, tableDataProvider) {
+        this._lookupType = FieldLookupTypeEnum.Dialog;
+        this._dialogTableDescriptor = lookupTableDescriptor;
+        this._dialogTableDataProvider = tableDataProvider;
+        return this;
+    }
+    asCustomComponent(customComponentName) {
+        this._lookupType = FieldLookupTypeEnum.Custom;
+        this._customComponentName = customComponentName;
+        return this;
+    }
+    copy() {
+        const field = new FieldLookupDescriptor(this._editor, this._property, {
+            dataProvider: this._dataProvider,
+            optionsValueProperty: this._optionsValueProperty
+        });
+        this.copyFieldsTo(field);
+        field._lookupType = this._lookupType;
+        field._optionsLabelProperty = this._optionsLabelProperty;
+        field._optionsLabelTranslate = this._optionsLabelTranslate;
+        field._optionsDisabledProperty = this._optionsDisabledProperty;
+        field._optionsTrackProperty = this._optionsTrackProperty;
+        field._dropdownClassName = this._dropdownClassName;
+        field._autocompleteOpenOnFocus = this._autocompleteOpenOnFocus;
+        field._autocompleteInlineSearch = this._autocompleteInlineSearch;
+        field._dialogTableDescriptor = this._dialogTableDescriptor;
+        return field;
+    }
+}
+export class FieldLookupEnumDescriptor extends FieldLookupDescriptor {
+    constructor(editor, property, enumType, options, nameAsValue = false, optionsTitlePath) {
+        super(editor, property, {
+            dataProvider: LookupDataProvider.create(),
+            optionsValueProperty: 'value'
+        });
+        this._nameAsValue = false;
+        this._enumType = enumType;
+        this._nameAsValue = nameAsValue;
+        if (typeof optionsTitlePath === 'undefined') {
+            optionsTitlePath = DecoratorMetadataUtil.findEnumName(enumType);
+        }
+        this._optionEnumValues = Array.isArray(options)
+            ? EnumUtil.fromValuesAsEnumValueArray(enumType, options, nameAsValue, optionsTitlePath ?? undefined)
+            : EnumUtil.fromConstantsAsEnumValueArray(enumType, nameAsValue, optionsTitlePath ?? undefined);
+        this.withLookup(() => of(this._optionEnumValues));
+        this.withOptionsLabelProperty('title', optionsTitlePath !== null);
+        this.withOptionsDisabledProperty('disabled');
+    }
+    get enumType() {
+        return this._enumType;
+    }
+    withDisabledOptions(...disabledOptions) {
+        for (const disabledOption of disabledOptions) {
+            const disabledOptionValue = this._nameAsValue ? EnumUtil.getConstantName(this._enumType, disabledOption) : disabledOption;
+            if (disabledOptionValue) {
+                const option = this._optionEnumValues.find(o => o.value === disabledOptionValue);
+                if (option) {
+                    option.disabled = true;
+                }
+            }
+        }
+        return this;
+    }
+    withDefaultValueEnum(defaultValue) {
+        const defaultOptionValue = this._nameAsValue ? EnumUtil.getConstantName(this._enumType, defaultValue) : defaultValue;
+        if (defaultOptionValue) {
+            const option = this._optionEnumValues.find(o => o.value === defaultOptionValue);
+            if (option) {
+                this.withDefaultValue(option[this._optionsValueProperty]);
+            }
+        }
+        return this;
+    }
+    asAutocomplete(opts) {
+        super.asAutocomplete({
+            ...opts,
+            openOnFocus: opts?.openOnFocus ?? true,
+            inlineSearch: opts?.inlineSearch ?? true
+        });
+        return this;
+    }
+    copy() {
+        const field = new FieldLookupEnumDescriptor(this._editor, this._property, this._enumType, []);
+        this.copyFieldsTo(field);
+        field._lookupType = this._lookupType;
+        field._optionsLabelProperty = this._optionsLabelProperty;
+        field._optionsDisabledProperty = this._optionsDisabledProperty;
+        field._optionsTrackProperty = this._optionsTrackProperty;
+        return field;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-lookup.descriptor.js","sourceRoot":"","sources":["../../../../../src/lib/descriptors/editor/field-lookup.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {of} from 'rxjs';\n\nimport {IDataProvider, ILookupDataProvider, ITableDataProvider, LookupDataProvider, LookupDataProviderLookupFnType} from '../../data-providers';\nimport {EnumValue} from '../../models';\nimport {ClassType, EnumConstantType, EnumType, ServiceClassType} from '../../types';\nimport {DecoratorMetadataUtil, EnumUtil, ModelUtil} from '../../utils';\nimport {FieldLookupConfig, ILookupDescriptor} from '../interfaces';\nimport {TableDescriptorInst} from '../table';\nimport {FieldLookupTypeEnum} from '../types';\nimport {AFieldDescriptor} from './field-base.descriptor';\nimport {IEditorDescriptorInternal} from './internal/editor.model';\n\nexport type FieldLookupDescriptorConstructorOptsType<EditorModel, Service> = FieldLookupDescriptorCreateOptsProviderType<EditorModel, Service> & {\n    type?: ClassType<EditorModel>;\n    optionsValueProperty?: string;\n};\n\nexport type FieldLookupDescriptorCreateOptsProviderType<FieldModel, Service> = {\n    serviceType?: ServiceClassType<Service>;\n    dataProvider?: ILookupDataProvider<FieldModel, Service>;\n};\n\nexport type FieldLookupProviderType<FieldModel, Service> = ServiceClassType<Service> | ILookupDataProvider<FieldModel, Service>;\n\nexport type FieldLookupAutocompleteOptsType = {\n    openOnFocus?: boolean;\n    inlineSearch?: boolean;\n    selectFirst?: boolean;\n    autoClear?: boolean;\n};\n\nexport const fieldLookupGetProviderCfgObj = <FieldModel, Service>(serviceOrDataProvider?: FieldLookupProviderType<FieldModel, Service>) => {\n    const cfg: FieldLookupDescriptorCreateOptsProviderType<FieldModel, Service> = {};\n    if (serviceOrDataProvider) {\n        if ((serviceOrDataProvider as IDataProvider).isDataProvider) {\n            // type casting needed, cause there was no other way found to differentiate the types\n            cfg.dataProvider = serviceOrDataProvider as ILookupDataProvider<FieldModel, Service>;\n        } else {\n            cfg.serviceType = serviceOrDataProvider as ServiceClassType<Service>;\n        }\n    }\n    return cfg;\n};\n\n// TODO: Generiki na daljša in jasna poimenovanja (kaj predstavlja)\nexport class FieldLookupDescriptor<FieldModel, EditorModel, Service = any, FieldValue = FieldModel, Property = string>\n    extends AFieldDescriptor<FieldModel, EditorModel, FieldValue>\n    implements ILookupDescriptor<FieldModel, Service>\n{\n    protected readonly _dataProvider: ILookupDataProvider<FieldModel, Service>;\n    protected readonly _optionsValueProperty?: string; // this defines VT!\n\n    protected _lookupType: FieldLookupTypeEnum = FieldLookupTypeEnum.Dropdown;\n    protected _optionsLabelProperty?: string;\n    protected _optionsLabelTranslate = false;\n    protected _optionsDisabledProperty?: string;\n    protected _optionsTrackProperty?: string;\n\n    protected _dropdownClassName = 'mng-filter-lookup-dropdown';\n\n    protected _autocompleteOpenOnFocus?: boolean;\n    protected _autocompleteInlineSearch?: boolean;\n    protected _autocompleteAutoClear?: boolean;\n    protected _autocompleteSelectFirst?: boolean;\n\n    protected _dialogTableDescriptor?: TableDescriptorInst<FieldModel>;\n    protected _dialogTableDataProvider?: ITableDataProvider<FieldModel, any>;\n\n    protected _customComponentName?: string;\n\n    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: Property, cfg?: FieldLookupDescriptorConstructorOptsType<FieldModel, Service>) {\n        super(editor, property as string);\n\n        if (cfg?.dataProvider) {\n            this._dataProvider = cfg.dataProvider;\n        } else {\n            this._dataProvider = LookupDataProvider.fromAnyParam(cfg?.type, cfg?.serviceType);\n        }\n\n        this._optionsValueProperty = cfg?.optionsValueProperty;\n\n        ModelUtil.trySetLookupItemsProperties(this);\n    }\n\n    public get lookupType() {\n        return this._lookupType;\n    }\n\n    public get optionsLabelProperty() {\n        return this._optionsLabelProperty;\n    }\n\n    public get optionsLabelTranslate() {\n        return this._optionsLabelTranslate;\n    }\n\n    public get optionsValueProperty() {\n        return this._optionsValueProperty;\n    }\n\n    public get optionsDisabledProperty() {\n        return this._optionsDisabledProperty;\n    }\n\n    public get optionsTrackProperty() {\n        return this._optionsTrackProperty;\n    }\n\n    public get dataProvider() {\n        return this._dataProvider;\n    }\n\n    public get autocompleteOpenOnFocus() {\n        return this._autocompleteOpenOnFocus;\n    }\n\n    public get autocompleteInlineSearch() {\n        return this._autocompleteInlineSearch;\n    }\n\n    public get autocompleteAutoClear() {\n        return this._autocompleteAutoClear;\n    }\n\n    public get autocompleteSelectFirst() {\n        return this._autocompleteSelectFirst;\n    }\n\n    public get dropdownClassName() {\n        return this._dropdownClassName;\n    }\n\n    public get dialogTableDescriptor() {\n        return this._dialogTableDescriptor;\n    }\n\n    public get dialogTableDataProvider() {\n        return this._dialogTableDataProvider;\n    }\n\n    public get customComponentName() {\n        return this._customComponentName;\n    }\n\n    public withOptionsLabelProperty(property: keyof FieldModel, translate = false): this {\n        return this.withOptionsLabelPropertyUnsafe(property as string, translate);\n    }\n\n    public withOptionsLabelPropertyUnsafe(property: string, translate = false): this {\n        this._optionsLabelProperty = property;\n        this._optionsLabelTranslate = translate;\n        return this;\n    }\n\n    public withOptionsDisabledProperty(property: keyof FieldModel): this {\n        return this.withOptionsDisabledPropertyUnsafe(property as string);\n    }\n\n    public withOptionsDisabledPropertyUnsafe(property: string): this {\n        this._optionsDisabledProperty = property;\n        return this;\n    }\n\n    public withOptionsTrackProperty(property: keyof FieldModel): this {\n        return this.withOptionsTrackPropertyUnsafe(property as string);\n    }\n\n    public withOptionsTrackPropertyUnsafe(property: string): this {\n        if (this._optionsValueProperty) {\n            return this;\n        }\n        this._optionsTrackProperty = property;\n        return this;\n    }\n\n    public withLookup(lookup?: LookupDataProviderLookupFnType<FieldModel, Service>): this {\n        this._dataProvider.withLookup(lookup);\n        return this;\n    }\n\n    public override withConfig(config: FieldLookupConfig): this {\n        return super.withConfig(config);\n    }\n\n    public asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this {\n        this._lookupType = FieldLookupTypeEnum.Autocomplete;\n        this._autocompleteAutoClear = opts?.autoClear;\n        this._autocompleteSelectFirst = opts?.selectFirst;\n        this._autocompleteOpenOnFocus = opts?.openOnFocus;\n        this._autocompleteInlineSearch = opts?.inlineSearch;\n        return this;\n    }\n\n    public asDialog(lookupTableDescriptor: TableDescriptorInst<FieldModel>, tableDataProvider?: ITableDataProvider<FieldModel, any>): this {\n        this._lookupType = FieldLookupTypeEnum.Dialog;\n        this._dialogTableDescriptor = lookupTableDescriptor;\n        this._dialogTableDataProvider = tableDataProvider;\n        return this;\n    }\n\n    public asCustomComponent(customComponentName: string): this {\n        this._lookupType = FieldLookupTypeEnum.Custom;\n        this._customComponentName = customComponentName;\n        return this;\n    }\n\n    public copy(): FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue> {\n        const field = new FieldLookupDescriptor<FieldModel, EditorModel, Service, FieldValue>(this._editor, this._property, {\n            dataProvider: this._dataProvider,\n            optionsValueProperty: this._optionsValueProperty\n        });\n        this.copyFieldsTo(field);\n        field._lookupType = this._lookupType;\n        field._optionsLabelProperty = this._optionsLabelProperty;\n        field._optionsLabelTranslate = this._optionsLabelTranslate;\n        field._optionsDisabledProperty = this._optionsDisabledProperty;\n        field._optionsTrackProperty = this._optionsTrackProperty;\n        field._dropdownClassName = this._dropdownClassName;\n        field._autocompleteOpenOnFocus = this._autocompleteOpenOnFocus;\n        field._autocompleteInlineSearch = this._autocompleteInlineSearch;\n        field._dialogTableDescriptor = this._dialogTableDescriptor;\n        return field;\n    }\n}\n\nexport class FieldLookupEnumDescriptor<EditorModel> extends FieldLookupDescriptor<EnumValue, EditorModel, undefined, EnumConstantType> {\n    private readonly _enumType: EnumType;\n    private readonly _optionEnumValues: EnumValue[];\n    private readonly _nameAsValue: boolean = false;\n\n    constructor(\n        editor: IEditorDescriptorInternal<EditorModel>,\n        property: string,\n        enumType: EnumType,\n        options?: Array<EnumConstantType>,\n        nameAsValue = false,\n        optionsTitlePath?: string | null\n    ) {\n        super(editor, property, {\n            dataProvider: LookupDataProvider.create<EnumValue>(),\n            optionsValueProperty: 'value'\n        });\n        this._enumType = enumType;\n        this._nameAsValue = nameAsValue;\n        if (typeof optionsTitlePath === 'undefined') {\n            optionsTitlePath = DecoratorMetadataUtil.findEnumName(enumType);\n        }\n        this._optionEnumValues = Array.isArray(options)\n            ? EnumUtil.fromValuesAsEnumValueArray(enumType, options, nameAsValue, optionsTitlePath ?? undefined)\n            : EnumUtil.fromConstantsAsEnumValueArray(enumType, nameAsValue, optionsTitlePath ?? undefined);\n        this.withLookup(() => of(this._optionEnumValues));\n        this.withOptionsLabelProperty('title', optionsTitlePath !== null);\n        this.withOptionsDisabledProperty('disabled');\n    }\n\n    public get enumType() {\n        return this._enumType;\n    }\n\n    public withDisabledOptions(...disabledOptions: Array<EnumConstantType>): this {\n        for (const disabledOption of disabledOptions) {\n            const disabledOptionValue = this._nameAsValue ? EnumUtil.getConstantName(this._enumType, disabledOption) : disabledOption;\n            if (disabledOptionValue) {\n                const option = this._optionEnumValues.find(o => o.value === disabledOptionValue);\n                if (option) {\n                    option.disabled = true;\n                }\n            }\n        }\n        return this;\n    }\n\n    public withDefaultValueEnum(defaultValue: EnumConstantType): this {\n        const defaultOptionValue = this._nameAsValue ? EnumUtil.getConstantName(this._enumType, defaultValue) : defaultValue;\n        if (defaultOptionValue) {\n            const option = this._optionEnumValues.find(o => o.value === defaultOptionValue);\n            if (option) {\n                this.withDefaultValue(option[this._optionsValueProperty as keyof object]);\n            }\n        }\n        return this;\n    }\n\n    public override asAutocomplete(opts?: FieldLookupAutocompleteOptsType): this {\n        super.asAutocomplete({\n            ...opts,\n            openOnFocus: opts?.openOnFocus ?? true,\n            inlineSearch: opts?.inlineSearch ?? true\n        });\n        return this;\n    }\n\n    public override copy(): FieldLookupEnumDescriptor<EditorModel> {\n        const field = new FieldLookupEnumDescriptor<EditorModel>(this._editor, this._property, this._enumType, []);\n        this.copyFieldsTo(field);\n        field._lookupType = this._lookupType;\n        field._optionsLabelProperty = this._optionsLabelProperty;\n        field._optionsDisabledProperty = this._optionsDisabledProperty;\n        field._optionsTrackProperty = this._optionsTrackProperty;\n        return field;\n    }\n}\n"]}

package/esm2022/lib/descriptors/editor/field-many.descriptor.mjs

@@ -0,0 +1,153 @@
+import { TableDataProvider } from '../../data-providers';
+import { FieldManyEditorActionEnum, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorTypeEnum } from '../types';
+import { AFieldDescriptor } from './field-base.descriptor';
+export const fieldManyToManyGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.lookupDataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.lookupServiceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+export class FieldManyToManyEditorDescriptor extends AFieldDescriptor {
+    constructor(editor, property, mainTableDescriptor, lookupTableDescriptor, cfg) {
+        super(editor, property);
+        this._fieldType = FieldManyToManyEditorTypeEnum.DialogTableMultiselect;
+        this._actions = [FieldManyToManyEditorActionEnum.Add, FieldManyToManyEditorActionEnum.Delete];
+        this._hasLookupExcludeValues = false;
+        this._excludeFilterProperty = '';
+        this._excludeValueProperty = '';
+        this._searchEnabled = false;
+        this._mainTableDescriptor = mainTableDescriptor;
+        this._lookupTableDescriptor = lookupTableDescriptor;
+        if (cfg?.lookupDataProvider) {
+            this._lookupTableDataProvider = cfg.lookupDataProvider;
+        }
+        else {
+            this._lookupTableDataProvider = TableDataProvider.fromAnyParam(lookupTableDescriptor.model.type, cfg?.lookupServiceType);
+        }
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get hasLookupExcludeValues() {
+        return this._hasLookupExcludeValues;
+    }
+    get excludeFilterProperty() {
+        return this._excludeFilterProperty;
+    }
+    get excludeValueProperty() {
+        return this._excludeValueProperty;
+    }
+    get mainTableDescriptor() {
+        return this._mainTableDescriptor;
+    }
+    get lookupTableDescriptor() {
+        return this._lookupTableDescriptor;
+    }
+    get lookupTableDataProvider() {
+        return this._lookupTableDataProvider;
+    }
+    get searchEnabled() {
+        return this._searchEnabled;
+    }
+    get searchFields() {
+        return this._searchFields;
+    }
+    withLookup(fn) {
+        this._lookupTableDataProvider.withGetAll(fn);
+        return this;
+    }
+    withActions(actions = []) {
+        this.actions.push(...actions);
+        return this;
+    }
+    withLookupExclude(filterProperty, valueProperty, hasLookupExclude = true) {
+        return this.withLookupExcludeUnsafe(filterProperty, valueProperty, hasLookupExclude);
+    }
+    withLookupExcludeUnsafe(filterProperty, valueProperty, hasLookupExclude = true) {
+        this._hasLookupExcludeValues = hasLookupExclude;
+        this._excludeFilterProperty = filterProperty;
+        this._excludeValueProperty = valueProperty;
+        return this;
+    }
+    withSearch(enabled = true, searchFields) {
+        this._searchEnabled = enabled;
+        this._searchFields = searchFields;
+        return this;
+    }
+    copy() {
+        const field = new FieldManyToManyEditorDescriptor(this._editor, this._property, this._mainTableDescriptor.copy(), this._lookupTableDescriptor.copy(), {
+            lookupDataProvider: this.lookupTableDataProvider
+        });
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._actions = this._actions.map(a => a);
+        field._hasLookupExcludeValues = this._hasLookupExcludeValues;
+        field._excludeFilterProperty = this._excludeFilterProperty;
+        field._excludeValueProperty = this._excludeValueProperty;
+        return field;
+    }
+}
+export class FieldManyEditorDescriptor extends AFieldDescriptor {
+    constructor(editor, property, tableviewDescriptor) {
+        super(editor, property);
+        this._fieldType = FieldManyEditorTypeEnum.DialogEditor;
+        this._fieldActions = [];
+        this._actions = [];
+        this._tableviewDescriptor = tableviewDescriptor;
+        this._fieldActions.push(FieldManyEditorActionEnum.View, FieldManyEditorActionEnum.Add, FieldManyEditorActionEnum.Edit, FieldManyEditorActionEnum.Delete);
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    get fieldActions() {
+        return this._fieldActions;
+    }
+    get actions() {
+        return this._actions;
+    }
+    get tableviewDescriptor() {
+        return this._tableviewDescriptor;
+    }
+    get tableDescriptor() {
+        return this._tableviewDescriptor.table;
+    }
+    get editorForCreate() {
+        return this._tableviewDescriptor.addEditor;
+    }
+    get editorForRead() {
+        return this._tableviewDescriptor.detailsEditor;
+    }
+    get editorForUpdate() {
+        return this._tableviewDescriptor.editEditor;
+    }
+    withFieldAction(action) {
+        this._fieldActions.push(action);
+        return this;
+    }
+    withFieldActions(actions) {
+        this._fieldActions = actions;
+        return this;
+    }
+    withAction(action) {
+        this._actions.push(action);
+        return this;
+    }
+    copy() {
+        const field = new FieldManyEditorDescriptor(this._editor, this._property, this._tableviewDescriptor.copy());
+        this.copyFieldsTo(field);
+        field._fieldType = this._fieldType;
+        field._fieldActions = this._fieldActions.map(a => a);
+        return field;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-many.descriptor.js","sourceRoot":"","sources":["../../../../../src/lib/descriptors/editor/field-many.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {IDataProvider, ITableDataProvider, TableDataProvider, TableDataProviderGetAllFnType} from '../../data-providers';\nimport {ServiceClassType} from '../../types';\nimport {ActionDescriptorInst} from '../action';\nimport {TableDescriptorInst} from '../table';\nimport {TableviewDescriptorInst} from '../tableview';\nimport {FieldManyEditorActionEnum, FieldManyEditorTypeEnum, FieldManyToManyEditorActionEnum, FieldManyToManyEditorTypeEnum} from '../types';\nimport {AFieldDescriptor} from './field-base.descriptor';\nimport {IEditorDescriptorInternal} from './internal/editor.model';\n\nexport type FieldManyToManyEditorDescriptorConstructorOptsType<FieldModel, Service> = FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service>;\n\nexport type FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service> = {\n    lookupServiceType?: ServiceClassType<Service>;\n    lookupDataProvider?: ITableDataProvider<FieldModel, Service>;\n};\n\nexport type FieldManyToManyEditorProviderType<FieldModel, Service> = ServiceClassType<Service> | ITableDataProvider<FieldModel, Service>;\n\nexport const fieldManyToManyGetProviderCfgObj = <FieldModel, Service>(serviceOrDataProvider?: FieldManyToManyEditorProviderType<FieldModel, Service>) => {\n    const cfg: FieldManyToManyEditorDescriptorCreateOptsProviderType<FieldModel, Service> = {};\n    if (serviceOrDataProvider) {\n        if ((serviceOrDataProvider as IDataProvider).isDataProvider) {\n            // type casting needed, cause there was no other way found to differentiate the types\n            cfg.lookupDataProvider = serviceOrDataProvider as ITableDataProvider<FieldModel, Service>;\n        } else {\n            cfg.lookupServiceType = serviceOrDataProvider as ServiceClassType<Service>;\n        }\n    }\n    return cfg;\n};\n\nexport class FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service = any, FieldValue = FieldModel[]> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue> {\n    private readonly _mainTableDescriptor: TableDescriptorInst<FieldModel>; // table descriptor for main table component\n    private readonly _lookupTableDescriptor: TableDescriptorInst<FieldModel>; // table descriptor for where select will be applied\n    private readonly _lookupTableDataProvider: ITableDataProvider<FieldModel, Service>;\n    private _fieldType: FieldManyToManyEditorTypeEnum = FieldManyToManyEditorTypeEnum.DialogTableMultiselect;\n    private _actions: Array<FieldManyToManyEditorActionEnum> = [FieldManyToManyEditorActionEnum.Add, FieldManyToManyEditorActionEnum.Delete];\n    private _hasLookupExcludeValues = false;\n    private _excludeFilterProperty = '';\n    private _excludeValueProperty = '';\n    private _searchEnabled = false;\n    private _searchFields?: string[];\n\n    constructor(\n        editor: IEditorDescriptorInternal<EditorModel>,\n        property: string,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        cfg?: FieldManyToManyEditorDescriptorConstructorOptsType<FieldModel, Service>\n    ) {\n        super(editor, property);\n        this._mainTableDescriptor = mainTableDescriptor;\n        this._lookupTableDescriptor = lookupTableDescriptor;\n\n        if (cfg?.lookupDataProvider) {\n            this._lookupTableDataProvider = cfg.lookupDataProvider;\n        } else {\n            this._lookupTableDataProvider = TableDataProvider.fromAnyParam(lookupTableDescriptor.model.type, cfg?.lookupServiceType);\n        }\n    }\n\n    public get fieldType() {\n        return this._fieldType;\n    }\n\n    public get actions() {\n        return this._actions;\n    }\n\n    public get hasLookupExcludeValues() {\n        return this._hasLookupExcludeValues;\n    }\n\n    public get excludeFilterProperty() {\n        return this._excludeFilterProperty;\n    }\n\n    public get excludeValueProperty() {\n        return this._excludeValueProperty;\n    }\n\n    public get mainTableDescriptor() {\n        return this._mainTableDescriptor;\n    }\n\n    public get lookupTableDescriptor() {\n        return this._lookupTableDescriptor;\n    }\n\n    public get lookupTableDataProvider() {\n        return this._lookupTableDataProvider;\n    }\n\n    public get searchEnabled() {\n        return this._searchEnabled;\n    }\n\n    public get searchFields() {\n        return this._searchFields;\n    }\n\n    public withLookup(fn: TableDataProviderGetAllFnType<FieldModel, Service>): this {\n        this._lookupTableDataProvider.withGetAll(fn);\n        return this;\n    }\n\n    public withActions(actions: Array<FieldManyToManyEditorActionEnum> = []): this {\n        this.actions.push(...actions);\n        return this;\n    }\n\n    public withLookupExclude(filterProperty: keyof FieldModel, valueProperty: keyof FieldModel, hasLookupExclude = true): this {\n        return this.withLookupExcludeUnsafe(filterProperty as string, valueProperty as string, hasLookupExclude);\n    }\n\n    public withLookupExcludeUnsafe(filterProperty: string, valueProperty: string, hasLookupExclude = true): this {\n        this._hasLookupExcludeValues = hasLookupExclude;\n        this._excludeFilterProperty = filterProperty;\n        this._excludeValueProperty = valueProperty;\n        return this;\n    }\n\n    public withSearch(enabled = true, searchFields?: string[]): this {\n        this._searchEnabled = enabled;\n        this._searchFields = searchFields;\n        return this;\n    }\n\n    public copy(): FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue> {\n        const field = new FieldManyToManyEditorDescriptor<FieldModel, EditorModel, Service, FieldValue>(\n            this._editor,\n            this._property,\n            this._mainTableDescriptor.copy(),\n            this._lookupTableDescriptor.copy(),\n            {\n                lookupDataProvider: this.lookupTableDataProvider\n            }\n        );\n        this.copyFieldsTo(field);\n        field._fieldType = this._fieldType;\n        field._actions = this._actions.map(a => a);\n        field._hasLookupExcludeValues = this._hasLookupExcludeValues;\n        field._excludeFilterProperty = this._excludeFilterProperty;\n        field._excludeValueProperty = this._excludeValueProperty;\n        return field;\n    }\n}\n\nexport class FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue = FieldModel[]> extends AFieldDescriptor<FieldModel, EditorModel, FieldValue> {\n    private readonly _tableviewDescriptor: TableviewDescriptorInst<FieldModel>;\n    private _fieldType: FieldManyEditorTypeEnum = FieldManyEditorTypeEnum.DialogEditor;\n    private _fieldActions: Array<FieldManyEditorActionEnum> = [];\n    private _actions: Array<ActionDescriptorInst<FieldModel>> = [];\n\n    constructor(editor: IEditorDescriptorInternal<EditorModel>, property: string, tableviewDescriptor: TableviewDescriptorInst<FieldModel>) {\n        super(editor, property);\n        this._tableviewDescriptor = tableviewDescriptor;\n        this._fieldActions.push(FieldManyEditorActionEnum.View, FieldManyEditorActionEnum.Add, FieldManyEditorActionEnum.Edit, FieldManyEditorActionEnum.Delete);\n    }\n\n    public get fieldType() {\n        return this._fieldType;\n    }\n\n    public get fieldActions() {\n        return this._fieldActions;\n    }\n\n    public get actions() {\n        return this._actions;\n    }\n\n    public get tableviewDescriptor() {\n        return this._tableviewDescriptor;\n    }\n\n    public get tableDescriptor() {\n        return this._tableviewDescriptor.table;\n    }\n\n    public get editorForCreate() {\n        return this._tableviewDescriptor.addEditor;\n    }\n\n    public get editorForRead() {\n        return this._tableviewDescriptor.detailsEditor;\n    }\n\n    public get editorForUpdate() {\n        return this._tableviewDescriptor.editEditor;\n    }\n\n    public withFieldAction(action: FieldManyEditorActionEnum): this {\n        this._fieldActions.push(action);\n        return this;\n    }\n\n    public withFieldActions(actions: FieldManyEditorActionEnum[]): this {\n        this._fieldActions = actions;\n        return this;\n    }\n\n    public withAction(action: ActionDescriptorInst<FieldModel>): this {\n        this._actions.push(action);\n        return this;\n    }\n\n    public copy(): FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue> {\n        const field = new FieldManyEditorDescriptor<FieldModel, EditorModel, FieldValue>(this._editor, this._property, this._tableviewDescriptor.copy());\n        this.copyFieldsTo(field);\n        field._fieldType = this._fieldType;\n        field._fieldActions = this._fieldActions.map(a => a);\n        return field;\n    }\n}\n"]}