@mediusinc/mng-commons 5.5.0 → 6.0.0-rc.2

package/esm2022/tableview/api/class/tableview/class-tableview-data-provider.factory.mjs

@@ -0,0 +1,5 @@
+import { TableviewDataProviderInst } from '@mediusinc/mng-commons/tableview/api';
+export function tableviewDataProviderFromClass(type, serviceType) {
+    return new TableviewDataProviderInst(serviceType);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3MtdGFibGV2aWV3LWRhdGEtcHJvdmlkZXIuZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3RhYmxldmlldy9hcGkvY2xhc3Mvc3JjL3RhYmxldmlldy9jbGFzcy10YWJsZXZpZXctZGF0YS1wcm92aWRlci5mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyx5QkFBeUIsRUFBQyxNQUFNLHNDQUFzQyxDQUFDO0FBUy9FLE1BQU0sVUFBVSw4QkFBOEIsQ0FDMUMsSUFBc0IsRUFDdEIsV0FBMEI7SUFFMUIsT0FBTyxJQUFJLHlCQUF5QixDQUErQyxXQUEyQixDQUFDLENBQUM7QUFDcEgsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q2xhc3NUeXBlLCBTZXJ2aWNlQ2xhc3NUeXBlfSBmcm9tICdAbWVkaXVzaW5jL21uZy1jb21tb25zL2NvcmUnO1xuaW1wb3J0IHtUYWJsZXZpZXdEYXRhUHJvdmlkZXJJbnN0fSBmcm9tICdAbWVkaXVzaW5jL21uZy1jb21tb25zL3RhYmxldmlldy9hcGknO1xuXG5leHBvcnQgZnVuY3Rpb24gdGFibGV2aWV3RGF0YVByb3ZpZGVyRnJvbUNsYXNzPE1vZGVsLCBTb3J0cyA9IGtleW9mIE1vZGVsLCBGaWx0ZXJzIGV4dGVuZHMga2V5b2YgYW55ID0ga2V5b2YgTW9kZWw+KFxuICAgIHR5cGU6IENsYXNzVHlwZTxNb2RlbD5cbik6IFRhYmxldmlld0RhdGFQcm92aWRlckluc3Q8TW9kZWwsIHVuZGVmaW5lZCwgU29ydHMsIEZpbHRlcnMsIHVuZGVmaW5lZD47XG5leHBvcnQgZnVuY3Rpb24gdGFibGV2aWV3RGF0YVByb3ZpZGVyRnJvbUNsYXNzPE1vZGVsLCBTZXJ2aWNlID0gYW55LCBTb3J0cyA9IGtleW9mIE1vZGVsLCBGaWx0ZXJzIGV4dGVuZHMga2V5b2YgYW55ID0ga2V5b2YgTW9kZWw+KFxuICAgIHR5cGU6IENsYXNzVHlwZTxNb2RlbD4sXG4gICAgc2VydmljZVR5cGU6IFNlcnZpY2VDbGFzc1R5cGU8U2VydmljZT5cbik6IFRhYmxldmlld0RhdGFQcm92aWRlckluc3Q8TW9kZWwsIFNlcnZpY2UsIFNvcnRzLCBGaWx0ZXJzLCBTZXJ2aWNlQ2xhc3NUeXBlPFNlcnZpY2U+PjtcbmV4cG9ydCBmdW5jdGlvbiB0YWJsZXZpZXdEYXRhUHJvdmlkZXJGcm9tQ2xhc3M8TW9kZWwsIFNlcnZpY2UgPSBhbnksIFNvcnRzID0ga2V5b2YgTW9kZWwsIEZpbHRlcnMgZXh0ZW5kcyBrZXlvZiBhbnkgPSBrZXlvZiBNb2RlbCwgU2VydmljZUNsYXNzID0gU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPj4oXG4gICAgdHlwZTogQ2xhc3NUeXBlPE1vZGVsPixcbiAgICBzZXJ2aWNlVHlwZT86IFNlcnZpY2VDbGFzc1xuKSB7XG4gICAgcmV0dXJuIG5ldyBUYWJsZXZpZXdEYXRhUHJvdmlkZXJJbnN0PE1vZGVsLCBTZXJ2aWNlLCBTb3J0cywgRmlsdGVycywgU2VydmljZUNsYXNzPihzZXJ2aWNlVHlwZSBhcyBTZXJ2aWNlQ2xhc3MpO1xufVxuIl19

package/esm2022/tableview/api/class/tableview/class-tableview-descriptor-helpers.mjs

@@ -0,0 +1,111 @@
+import { CommonsInternalError, TypeRegistry } from '@mediusinc/mng-commons/core';
+import { ModelClassDescriptor, findClassTitleAttribute } from '@mediusinc/mng-commons/model/class';
+import { ColumnTypeEnum } from '@mediusinc/mng-commons/table/api';
+import { modifyTableClassAttributeColumnTypeUnsafe, modifyTableColumnFilterLookupUnsafe, tableDescriptorModifyEnumColumnUnsafe } from '@mediusinc/mng-commons/table/api/class';
+import { FieldInputTypeEnum } from '@mediusinc/mng-commons/tableview/api';
+import { getFieldInputTypeFromColumnType } from '../editor/class-editor-attribute-converter';
+import { modifyEditorClassAttributeFieldEnumUnsafe, modifyEditorClassAttributeFieldTypeUnsafe, modifyEditorFieldLookupUnsafe } from '../editor/class-editor-descriptor-helpers';
+import { getTableviewClassAttributeDef } from './class-tableview-attribute-converter';
+/**
+ * creates column and field with custom type, for example currency
+ * if field exists, it is replaced
+ * DO NOT USE WITH TYPES WHERE ARGS ARE REQUIRED - ERROR WILL BE THROWN
+ * for enum use withEnumType
+ * for custom class use withClassType
+ * @param descriptor Tableview descriptor
+ * @param property name of field
+ * @param columnType required column type
+ * @param fieldType optional, if not provided it is converted from column type
+ * @param columnDisplayType optional
+ */
+export function modifyTableviewClassAttributeType(descriptor, property, columnType, fieldType, columnDisplayType) {
+    return modifyTableviewClassAttributeTypeUnsafe(descriptor, property, columnType, fieldType, columnDisplayType);
+}
+export function modifyTableviewClassAttributeTypeUnsafe(descriptor, property, columnType, fieldType, columnDisplayType) {
+    if (!(descriptor.model instanceof ModelClassDescriptor)) {
+        throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model descriptor is not of type 'ModelClassDescriptor' is not defined.`);
+    }
+    if (columnType === ColumnTypeEnum.Enum) {
+        throw new CommonsInternalError('Do not use with types where args are required', { name: 'TableviewDescriptorError' });
+    }
+    const attributeDef = getTableviewClassAttributeDef(descriptor.model.classType).find(attr => attr.name === property);
+    if (attributeDef != null) {
+        fieldType ??= getFieldInputTypeFromColumnType(columnType, columnDisplayType);
+        attributeDef.fieldType = fieldType;
+        modifyTableClassAttributeColumnTypeUnsafe(descriptor.table, property, columnType, columnDisplayType);
+        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.editEditor, property, fieldType);
+        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.addEditor, property, fieldType);
+        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.detailsEditor, property, fieldType);
+        return true;
+    }
+    return false;
+}
+/**
+ * creates column with enum type
+ * if fields exists, it is replaced
+ * @param descriptor Tableview descriptor
+ * @param property property name
+ * @param enumDesc type of enum
+ * @param fieldType type of field, optional, default is Text
+ */
+export function modifyTableviewClassAttributeEnum(descriptor, property, enumDesc, fieldType) {
+    return modifyTableviewClassAttributeEnumUnsafe(descriptor, property, enumDesc, fieldType);
+}
+export function modifyTableviewClassAttributeEnumUnsafe(descriptor, property, enumDesc, fieldType) {
+    if (!(descriptor.model instanceof ModelClassDescriptor)) {
+        throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model descriptor is not of type 'ModelClassDescriptor' is not defined.`);
+    }
+    const attributeDef = getTableviewClassAttributeDef(descriptor.model.classType).find(attr => attr.name === property);
+    if (attributeDef != null) {
+        attributeDef.fieldType = fieldType ?? FieldInputTypeEnum.Text;
+        tableDescriptorModifyEnumColumnUnsafe(descriptor.table, property, enumDesc);
+        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.editEditor, property, enumDesc);
+        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.addEditor, property, enumDesc);
+        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.detailsEditor, property, enumDesc);
+        return true;
+    }
+    return false;
+}
+/**
+ * generates column with custom class type
+ * field is generated only if lookupProvider is provided
+ * @param descriptor Tableview descriptor
+ * @param property property name
+ * @param type class type of object
+ * @param titleProperty
+ * @param lookupProvider
+ * @param optionsLabelProperty
+ * @param filterProperty
+ */
+export function modifyTableviewLookup(descriptor, property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
+    return modifyTableviewLookupUnsafe(descriptor, property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty);
+}
+export function modifyTableviewLookupUnsafe(descriptor, property, type, lookupProvider, titleProperty, optionsLabelProperty, filterProperty) {
+    if (!(descriptor.model instanceof ModelClassDescriptor)) {
+        throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model descriptor is not of type 'ModelClassDescriptor' is not defined.`);
+    }
+    const attributeDef = getTableviewClassAttributeDef(descriptor.model.classType).find(attr => attr.name === property);
+    if (attributeDef != null) {
+        type ??= attributeDef.classType ?? TypeRegistry.get().findType(attributeDef.type);
+        titleProperty ??= type ? (findClassTitleAttribute(type) ?? undefined) : undefined;
+        optionsLabelProperty ??= titleProperty;
+        attributeDef.columnType = ColumnTypeEnum.String;
+        attributeDef.fieldType = FieldInputTypeEnum.Text;
+        if (lookupProvider != null) {
+            modifyTableColumnFilterLookupUnsafe(descriptor.table, property, lookupProvider, optionsLabelProperty, filterProperty);
+            modifyEditorFieldLookupUnsafe(descriptor.addEditor, property, lookupProvider, optionsLabelProperty);
+            modifyEditorFieldLookupUnsafe(descriptor.detailsEditor, property, lookupProvider, optionsLabelProperty);
+            modifyEditorFieldLookupUnsafe(descriptor.editEditor, property, lookupProvider, optionsLabelProperty);
+            return true;
+        }
+        else {
+            const column = descriptor.table.getColumnUnsafe(property) ?? descriptor.addColumnUnsafe(property);
+            if (titleProperty) {
+                column.withGetter(value => value?.[titleProperty]);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-tableview-descriptor-helpers.js","sourceRoot":"","sources":["../../../../../../tableview/api/class/src/tableview/class-tableview-descriptor-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import {ClassType, CommonsInternalError, ILookupDataProvider, TypeRegistry} from '@mediusinc/mng-commons/core';\nimport {EnumDescriptor} from '@mediusinc/mng-commons/model';\nimport {ModelClassDescriptor, findClassTitleAttribute} from '@mediusinc/mng-commons/model/class';\nimport {ColumnDisplayTypeEnum, ColumnTypeEnum} from '@mediusinc/mng-commons/table/api';\nimport {modifyTableClassAttributeColumnTypeUnsafe, modifyTableColumnFilterLookupUnsafe, tableDescriptorModifyEnumColumnUnsafe} from '@mediusinc/mng-commons/table/api/class';\nimport {FieldInputTypeEnum, TableviewDescriptorInst} from '@mediusinc/mng-commons/tableview/api';\n\nimport {getFieldInputTypeFromColumnType} from '../editor/class-editor-attribute-converter';\nimport {modifyEditorClassAttributeFieldEnumUnsafe, modifyEditorClassAttributeFieldTypeUnsafe, modifyEditorFieldLookupUnsafe} from '../editor/class-editor-descriptor-helpers';\nimport {getTableviewClassAttributeDef} from './class-tableview-attribute-converter';\n\n/**\n * creates column and field with custom type, for example currency\n * if field exists, it is replaced\n * DO NOT USE WITH TYPES WHERE ARGS ARE REQUIRED - ERROR WILL BE THROWN\n * for enum use withEnumType\n * for custom class use withClassType\n * @param descriptor Tableview descriptor\n * @param property name of field\n * @param columnType required column type\n * @param fieldType optional, if not provided it is converted from column type\n * @param columnDisplayType optional\n */\nexport function modifyTableviewClassAttributeType<TableviewModel>(\n    descriptor: TableviewDescriptorInst<TableviewModel, any, any>,\n    property: keyof TableviewModel,\n    columnType: ColumnTypeEnum,\n    fieldType?: FieldInputTypeEnum,\n    columnDisplayType?: ColumnDisplayTypeEnum\n): boolean {\n    return modifyTableviewClassAttributeTypeUnsafe(descriptor, property as string, columnType, fieldType, columnDisplayType);\n}\n\nexport function modifyTableviewClassAttributeTypeUnsafe<TableviewModel>(\n    descriptor: TableviewDescriptorInst<TableviewModel, any, any>,\n    property: string,\n    columnType: ColumnTypeEnum,\n    fieldType?: FieldInputTypeEnum,\n    columnDisplayType?: ColumnDisplayTypeEnum\n): boolean {\n    if (!(descriptor.model instanceof ModelClassDescriptor)) {\n        throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model descriptor is not of type 'ModelClassDescriptor' is not defined.`);\n    }\n    if (columnType === ColumnTypeEnum.Enum) {\n        throw new CommonsInternalError('Do not use with types where args are required', {name: 'TableviewDescriptorError'});\n    }\n\n    const attributeDef = getTableviewClassAttributeDef(descriptor.model.classType).find(attr => attr.name === property);\n\n    if (attributeDef != null) {\n        fieldType ??= getFieldInputTypeFromColumnType(columnType, columnDisplayType);\n        attributeDef.fieldType = fieldType;\n        modifyTableClassAttributeColumnTypeUnsafe(descriptor.table, property, columnType, columnDisplayType);\n        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.editEditor, property, fieldType);\n        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.addEditor, property, fieldType);\n        modifyEditorClassAttributeFieldTypeUnsafe(descriptor.detailsEditor, property, fieldType);\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * creates column with enum type\n * if fields exists, it is replaced\n * @param descriptor Tableview descriptor\n * @param property property name\n * @param enumDesc type of enum\n * @param fieldType type of field, optional, default is Text\n */\nexport function modifyTableviewClassAttributeEnum<TableviewModel, Property extends keyof TableviewModel, Enum extends NonNullable<TableviewModel[Property]>>(\n    descriptor: TableviewDescriptorInst<TableviewModel, any, any>,\n    property: Property,\n    enumDesc?: EnumDescriptor<Enum>,\n    fieldType?: FieldInputTypeEnum\n): boolean {\n    return modifyTableviewClassAttributeEnumUnsafe<TableviewModel, Enum>(descriptor, property as string, enumDesc, fieldType);\n}\n\nexport function modifyTableviewClassAttributeEnumUnsafe<TableviewModel, Enum = any>(\n    descriptor: TableviewDescriptorInst<TableviewModel, any, any>,\n    property: string,\n    enumDesc?: EnumDescriptor<Enum>,\n    fieldType?: FieldInputTypeEnum\n): boolean {\n    if (!(descriptor.model instanceof ModelClassDescriptor)) {\n        throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model descriptor is not of type 'ModelClassDescriptor' is not defined.`);\n    }\n    const attributeDef = getTableviewClassAttributeDef(descriptor.model.classType).find(attr => attr.name === property);\n\n    if (attributeDef != null) {\n        attributeDef.fieldType = fieldType ?? FieldInputTypeEnum.Text;\n        tableDescriptorModifyEnumColumnUnsafe(descriptor.table, property, enumDesc);\n        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.editEditor, property, enumDesc);\n        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.addEditor, property, enumDesc);\n        modifyEditorClassAttributeFieldEnumUnsafe(descriptor.detailsEditor, property, enumDesc);\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * generates column with custom class type\n * field is generated only if lookupProvider is provided\n * @param descriptor Tableview descriptor\n * @param property property name\n * @param type class type of object\n * @param titleProperty\n * @param lookupProvider\n * @param optionsLabelProperty\n * @param filterProperty\n */\nexport function modifyTableviewLookup<TableviewModel, Property extends keyof TableviewModel, LookupModel = NonNullable<TableviewModel[Property]>>(\n    descriptor: TableviewDescriptorInst<TableviewModel, any, any>,\n    property: Property,\n    type?: ClassType<LookupModel>,\n    lookupProvider?: ILookupDataProvider<LookupModel>,\n    titleProperty?: keyof LookupModel,\n    optionsLabelProperty?: keyof LookupModel,\n    filterProperty?: keyof LookupModel\n): boolean {\n    return modifyTableviewLookupUnsafe(descriptor, property as string, type, lookupProvider, titleProperty as string, optionsLabelProperty as string, filterProperty as string);\n}\n\nexport function modifyTableviewLookupUnsafe<TableviewModel, LookupModel>(\n    descriptor: TableviewDescriptorInst<TableviewModel, any, any>,\n    property: string,\n    type?: ClassType<LookupModel>,\n    lookupProvider?: ILookupDataProvider<LookupModel>,\n    titleProperty?: string,\n    optionsLabelProperty?: string,\n    filterProperty?: string\n): boolean {\n    if (!(descriptor.model instanceof ModelClassDescriptor)) {\n        throw new CommonsInternalError(`withFieldModifiedType cannot be executed for property ${property}: Model descriptor is not of type 'ModelClassDescriptor' is not defined.`);\n    }\n\n    const attributeDef = getTableviewClassAttributeDef(descriptor.model.classType).find(attr => attr.name === property);\n\n    if (attributeDef != null) {\n        type ??= attributeDef.classType ?? TypeRegistry.get().findType(attributeDef.type);\n        titleProperty ??= type ? (findClassTitleAttribute(type) ?? undefined) : undefined;\n        optionsLabelProperty ??= titleProperty;\n        attributeDef.columnType = ColumnTypeEnum.String;\n        attributeDef.fieldType = FieldInputTypeEnum.Text;\n\n        if (lookupProvider != null) {\n            modifyTableColumnFilterLookupUnsafe(descriptor.table, property, lookupProvider, optionsLabelProperty, filterProperty);\n            modifyEditorFieldLookupUnsafe(descriptor.addEditor, property, lookupProvider, optionsLabelProperty);\n            modifyEditorFieldLookupUnsafe(descriptor.detailsEditor, property, lookupProvider, optionsLabelProperty);\n            modifyEditorFieldLookupUnsafe(descriptor.editEditor, property, lookupProvider, optionsLabelProperty);\n            return true;\n        } else {\n            const column = descriptor.table.getColumnUnsafe(property) ?? descriptor.addColumnUnsafe(property);\n            if (titleProperty) {\n                column.withGetter(value => value?.[titleProperty as keyof object]);\n            }\n            return true;\n        }\n    }\n\n    return false;\n}\n"]}

package/esm2022/tableview/api/class/tableview/class-tableview-descriptor.factory.mjs

@@ -0,0 +1,26 @@
+import { modelClass } from '@mediusinc/mng-commons/model/class';
+import { tableDescriptorFromClassAttrsDef } from '@mediusinc/mng-commons/table/api/class';
+import { TableviewDescriptorInst, TableviewEditorTypeEnum } from '@mediusinc/mng-commons/tableview/api';
+import { editorDescriptorFromClassAttrsDef } from '../editor/class-editor-descriptor.factory';
+export function tableviewDescriptorFromClass(type, opts) {
+    return new TableviewDescriptorInst(modelClass(type, opts));
+}
+/**
+ * generates descriptor based on type attribute definition
+ * @param type class type
+ * @param columnAttributes
+ * @param fieldAttributes
+ * @param opts
+ */
+export function tableviewDescriptorFromClassAttrsDef(type, columnAttributes, fieldAttributes, opts) {
+    const model = modelClass(type, opts);
+    const descriptor = new TableviewDescriptorInst(model);
+    descriptor.withTableDescriptor(tableDescriptorFromClassAttrsDef(type, columnAttributes, opts));
+    if (fieldAttributes !== null) {
+        descriptor.withEditDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...opts, tableviewEditorType: TableviewEditorTypeEnum.Edit }));
+        descriptor.withDetailsDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...opts, tableviewEditorType: TableviewEditorTypeEnum.Details }).withDisabled());
+        descriptor.withAddDescriptor(editorDescriptorFromClassAttrsDef(type, fieldAttributes ?? columnAttributes, { ...opts, tableviewEditorType: TableviewEditorTypeEnum.Add }));
+    }
+    return descriptor;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tableview/api/editor/data-providers/editor-data-provider.factory.mjs

@@ -1,33 +1,15 @@
 import { EditorDataProviderInst } from './editor.data-provider';
-export class EditorDataProvider extends EditorDataProviderInst {
-    constructor() {
-        super(undefined, undefined);
-    }
-    static create() {
-        return editorDataProvider();
-    }
-    static fromClass(type) {
-        return editorDataProviderFromClass(type);
-    }
-    static fromClassWithService(type, serviceType) {
-        return editorDataProviderFromClass(type, serviceType);
-    }
-    static fromService(serviceType) {
-        return editorDataProviderWithService(serviceType);
-    }
-}
-export function editorDataProvider(type, serviceType) {
-    return new EditorDataProviderInst(undefined, serviceType);
-}
-export function editorDataProviderWithService(serviceType) {
-    return new EditorDataProviderInst(undefined, serviceType);
-}
-export function editorDataProviderFromClass(type, serviceType) {
-    return new EditorDataProviderInst(type, serviceType);
-}
-export function editorDataProviderFromModel(model, serviceType) {
-    return typeof serviceType !== 'undefined'
-        ? new EditorDataProviderInst(model.type, serviceType)
-        : new EditorDataProviderInst(model.type, undefined);
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWRpdG9yLWRhdGEtcHJvdmlkZXIuZmFjdG9yeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3RhYmxldmlldy9hcGkvc3JjL2VkaXRvci9kYXRhLXByb3ZpZGVycy9lZGl0b3ItZGF0YS1wcm92aWRlci5mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLHdCQUF3QixDQUFDO0FBRTlELE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxzQkFBMkI7SUFDL0Q7UUFDSSxLQUFLLENBQUMsU0FBUyxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFTSxNQUFNLENBQUMsTUFBTTtRQUNoQixPQUFPLGtCQUFrQixFQUFFLENBQUM7SUFDaEMsQ0FBQztJQUVNLE1BQU0sQ0FBQyxTQUFTLENBQVEsSUFBc0I7UUFDakQsT0FBTywyQkFBMkIsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBRU0sTUFBTSxDQUFDLG9CQUFvQixDQUM5QixJQUFzQixFQUN0QixXQUFzQztRQUV0QyxPQUFPLDJCQUEyQixDQUFDLElBQUksRUFBRSxXQUFXLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBRU0sTUFBTSxDQUFDLFdBQVcsQ0FBaUIsV0FBc0M7UUFDNUUsT0FBTyw2QkFBNkIsQ0FBaUIsV0FBVyxDQUFDLENBQUM7SUFDdEUsQ0FBQztDQUNKO0FBUUQsTUFBTSxVQUFVLGtCQUFrQixDQUFpRSxJQUE0QixFQUFFLFdBQTBCO0lBQ3ZKLE9BQU8sSUFBSSxzQkFBc0IsQ0FBMEMsU0FBUyxFQUFFLFdBQTJCLENBQUMsQ0FBQztBQUN2SCxDQUFDO0FBRUQsTUFBTSxVQUFVLDZCQUE2QixDQUN6QyxXQUFzQztJQUV0QyxPQUFPLElBQUksc0JBQXNCLENBQXVELFNBQVMsRUFBRSxXQUFXLENBQUMsQ0FBQztBQUNwSCxDQUFDO0FBT0QsTUFBTSxVQUFVLDJCQUEyQixDQUFpRSxJQUFzQixFQUFFLFdBQTBCO0lBQzFKLE9BQU8sSUFBSSxzQkFBc0IsQ0FBaUQsSUFBSSxFQUFFLFdBQTJCLENBQUMsQ0FBQztBQUN6SCxDQUFDO0FBU0QsTUFBTSxVQUFVLDJCQUEyQixDQUN2QyxLQUF5QyxFQUN6QyxXQUEwQjtJQUUxQixPQUFPLE9BQU8sV0FBVyxLQUFLLFdBQVc7UUFDckMsQ0FBQyxDQUFDLElBQUksc0JBQXNCLENBQThELEtBQUssQ0FBQyxJQUF3QixFQUFFLFdBQXdDLENBQUM7UUFDbkssQ0FBQyxDQUFDLElBQUksc0JBQXNCLENBQWdELEtBQUssQ0FBQyxJQUF3QixFQUFFLFNBQVMsQ0FBQyxDQUFDO0FBQy9ILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NsYXNzVHlwZSwgU2VydmljZUNsYXNzVHlwZX0gZnJvbSAnQG1lZGl1c2luYy9tbmctY29tbW9ucy9jb3JlJztcbmltcG9ydCB7TW9kZWxEZXNjcmlwdG9yLCBUeXBlRGVzY3JpcHRvcn0gZnJvbSAnQG1lZGl1c2luYy9tbmctY29tbW9ucy9tb2RlbCc7XG5cbmltcG9ydCB7RWRpdG9yRGF0YVByb3ZpZGVySW5zdH0gZnJvbSAnLi9lZGl0b3IuZGF0YS1wcm92aWRlcic7XG5cbmV4cG9ydCBjbGFzcyBFZGl0b3JEYXRhUHJvdmlkZXIgZXh0ZW5kcyBFZGl0b3JEYXRhUHJvdmlkZXJJbnN0PGFueT4ge1xuICAgIHByb3RlY3RlZCBjb25zdHJ1Y3RvcigpIHtcbiAgICAgICAgc3VwZXIodW5kZWZpbmVkLCB1bmRlZmluZWQpO1xuICAgIH1cblxuICAgIHB1YmxpYyBzdGF0aWMgY3JlYXRlPE1vZGVsPigpOiBFZGl0b3JEYXRhUHJvdmlkZXJJbnN0PE1vZGVsLCB1bmRlZmluZWQsIHVuZGVmaW5lZCwgdW5kZWZpbmVkPiB7XG4gICAgICAgIHJldHVybiBlZGl0b3JEYXRhUHJvdmlkZXIoKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgc3RhdGljIGZyb21DbGFzczxNb2RlbD4odHlwZTogQ2xhc3NUeXBlPE1vZGVsPik6IEVkaXRvckRhdGFQcm92aWRlckluc3Q8TW9kZWwsIHVuZGVmaW5lZCwgQ2xhc3NUeXBlPE1vZGVsPiwgdW5kZWZpbmVkPiB7XG4gICAgICAgIHJldHVybiBlZGl0b3JEYXRhUHJvdmlkZXJGcm9tQ2xhc3ModHlwZSk7XG4gICAgfVxuXG4gICAgcHVibGljIHN0YXRpYyBmcm9tQ2xhc3NXaXRoU2VydmljZTxNb2RlbCwgU2VydmljZT4oXG4gICAgICAgIHR5cGU6IENsYXNzVHlwZTxNb2RlbD4sXG4gICAgICAgIHNlcnZpY2VUeXBlOiBTZXJ2aWNlQ2xhc3NUeXBlPFNlcnZpY2U+XG4gICAgKTogRWRpdG9yRGF0YVByb3ZpZGVySW5zdDxNb2RlbCwgU2VydmljZSwgQ2xhc3NUeXBlPE1vZGVsPiwgU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPj4ge1xuICAgICAgICByZXR1cm4gZWRpdG9yRGF0YVByb3ZpZGVyRnJvbUNsYXNzKHR5cGUsIHNlcnZpY2VUeXBlKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgc3RhdGljIGZyb21TZXJ2aWNlPFNlcnZpY2UsIE1vZGVsPihzZXJ2aWNlVHlwZTogU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPik6IEVkaXRvckRhdGFQcm92aWRlckluc3Q8TW9kZWwsIFNlcnZpY2UsIHVuZGVmaW5lZCwgU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPj4ge1xuICAgICAgICByZXR1cm4gZWRpdG9yRGF0YVByb3ZpZGVyV2l0aFNlcnZpY2U8U2VydmljZSwgTW9kZWw+KHNlcnZpY2VUeXBlKTtcbiAgICB9XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBlZGl0b3JEYXRhUHJvdmlkZXI8TW9kZWw+KCk6IEVkaXRvckRhdGFQcm92aWRlckluc3Q8TW9kZWwsIHVuZGVmaW5lZCwgdW5kZWZpbmVkLCB1bmRlZmluZWQ+O1xuZXhwb3J0IGZ1bmN0aW9uIGVkaXRvckRhdGFQcm92aWRlcjxNb2RlbD4odHlwZTogVHlwZURlc2NyaXB0b3I8TW9kZWw+KTogRWRpdG9yRGF0YVByb3ZpZGVySW5zdDxNb2RlbCwgdW5kZWZpbmVkLCB1bmRlZmluZWQsIHVuZGVmaW5lZD47XG5leHBvcnQgZnVuY3Rpb24gZWRpdG9yRGF0YVByb3ZpZGVyPE1vZGVsLCBTZXJ2aWNlID0gYW55PihcbiAgICB0eXBlOiBUeXBlRGVzY3JpcHRvcjxNb2RlbD4sXG4gICAgc2VydmljZVR5cGU6IFNlcnZpY2VDbGFzc1R5cGU8U2VydmljZT5cbik6IEVkaXRvckRhdGFQcm92aWRlckluc3Q8TW9kZWwsIFNlcnZpY2UsIHVuZGVmaW5lZCwgU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPj47XG5leHBvcnQgZnVuY3Rpb24gZWRpdG9yRGF0YVByb3ZpZGVyPE1vZGVsLCBTZXJ2aWNlID0gYW55LCBTZXJ2aWNlQ2xhc3MgPSBTZXJ2aWNlQ2xhc3NUeXBlPFNlcnZpY2U+Pih0eXBlPzogVHlwZURlc2NyaXB0b3I8TW9kZWw+LCBzZXJ2aWNlVHlwZT86IFNlcnZpY2VDbGFzcykge1xuICAgIHJldHVybiBuZXcgRWRpdG9yRGF0YVByb3ZpZGVySW5zdDxNb2RlbCwgU2VydmljZSwgdW5kZWZpbmVkLCBTZXJ2aWNlQ2xhc3M+KHVuZGVmaW5lZCwgc2VydmljZVR5cGUgYXMgU2VydmljZUNsYXNzKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGVkaXRvckRhdGFQcm92aWRlcldpdGhTZXJ2aWNlPFNlcnZpY2UsIE1vZGVsPihcbiAgICBzZXJ2aWNlVHlwZTogU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPlxuKTogRWRpdG9yRGF0YVByb3ZpZGVySW5zdDxNb2RlbCwgU2VydmljZSwgdW5kZWZpbmVkLCBTZXJ2aWNlQ2xhc3NUeXBlPFNlcnZpY2U+PiB7XG4gICAgcmV0dXJuIG5ldyBFZGl0b3JEYXRhUHJvdmlkZXJJbnN0PE1vZGVsLCBTZXJ2aWNlLCB1bmRlZmluZWQsIFNlcnZpY2VDbGFzc1R5cGU8U2VydmljZT4+KHVuZGVmaW5lZCwgc2VydmljZVR5cGUpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZWRpdG9yRGF0YVByb3ZpZGVyRnJvbUNsYXNzPE1vZGVsPih0eXBlOiBDbGFzc1R5cGU8TW9kZWw+KTogRWRpdG9yRGF0YVByb3ZpZGVySW5zdDxNb2RlbCwgdW5kZWZpbmVkLCBDbGFzc1R5cGU8TW9kZWw+LCB1bmRlZmluZWQ+O1xuZXhwb3J0IGZ1bmN0aW9uIGVkaXRvckRhdGFQcm92aWRlckZyb21DbGFzczxNb2RlbCwgU2VydmljZSA9IGFueT4oXG4gICAgdHlwZTogQ2xhc3NUeXBlPE1vZGVsPixcbiAgICBzZXJ2aWNlVHlwZTogU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPlxuKTogRWRpdG9yRGF0YVByb3ZpZGVySW5zdDxNb2RlbCwgU2VydmljZSwgQ2xhc3NUeXBlPE1vZGVsPiwgU2VydmljZUNsYXNzVHlwZTxTZXJ2aWNlPj47XG5leHBvcnQgZnVuY3Rpb24gZWRpdG9yRGF0YVByb3ZpZGVyRnJvbUNsYXNzPE1vZGVsLCBTZXJ2aWNlID0gYW55LCBTZXJ2aWNlQ2xhc3MgPSBTZXJ2aWNlQ2xhc3NUeXBlPFNlcnZpY2U+Pih0eXBlOiBDbGFzc1R5cGU8TW9kZWw+LCBzZXJ2aWNlVHlwZT86IFNlcnZpY2VDbGFzcykge1xuICAgIHJldHVybiBuZXcgRWRpdG9yRGF0YVByb3ZpZGVySW5zdDxNb2RlbCwgU2VydmljZSwgQ2xhc3NUeXBlPE1vZGVsPiwgU2VydmljZUNsYXNzPih0eXBlLCBzZXJ2aWNlVHlwZSBhcyBTZXJ2aWNlQ2xhc3MpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZWRpdG9yRGF0YVByb3ZpZGVyRnJvbU1vZGVsPE1vZGVsLCBNb2RlbENsYXNzID0gQ2xhc3NUeXBlPE1vZGVsPj4oXG4gICAgbW9kZWw6IE1vZGVsRGVzY3JpcHRvcjxNb2RlbCwgTW9kZWxDbGFzcz5cbik6IEVkaXRvckRhdGFQcm92aWRlckluc3Q8TW9kZWwsIHVuZGVmaW5lZCwgTW9kZWxDbGFzcywgdW5kZWZpbmVkPjtcbmV4cG9ydCBmdW5jdGlvbiBlZGl0b3JEYXRhUHJvdmlkZXJGcm9tTW9kZWw8TW9kZWwsIFNlcnZpY2UgPSBhbnksIE1vZGVsQ2xhc3MgPSBDbGFzc1R5cGU8TW9kZWw+PihcbiAgICBtb2RlbDogTW9kZWxEZXNjcmlwdG9yPE1vZGVsLCBNb2RlbENsYXNzPixcbiAgICBTZXJ2aWNlQ2xhc3M6IFNlcnZpY2VDbGFzc1R5cGU8U2VydmljZT5cbik6IEVkaXRvckRhdGFQcm92aWRlckluc3Q8TW9kZWwsIFNlcnZpY2UsIE1vZGVsQ2xhc3MsIFNlcnZpY2VDbGFzc1R5cGU8U2VydmljZT4+O1xuZXhwb3J0IGZ1bmN0aW9uIGVkaXRvckRhdGFQcm92aWRlckZyb21Nb2RlbDxNb2RlbCwgU2VydmljZSA9IGFueSwgTW9kZWxDbGFzcyA9IENsYXNzVHlwZTxNb2RlbD4sIFNlcnZpY2VDbGFzcyA9IFNlcnZpY2VDbGFzc1R5cGU8U2VydmljZT4+KFxuICAgIG1vZGVsOiBNb2RlbERlc2NyaXB0b3I8TW9kZWwsIE1vZGVsQ2xhc3M+LFxuICAgIHNlcnZpY2VUeXBlPzogU2VydmljZUNsYXNzXG4pIHtcbiAgICByZXR1cm4gdHlwZW9mIHNlcnZpY2VUeXBlICE9PSAndW5kZWZpbmVkJ1xuICAgICAgICA/IG5ldyBFZGl0b3JEYXRhUHJvdmlkZXJJbnN0PE1vZGVsLCBTZXJ2aWNlLCBDbGFzc1R5cGU8TW9kZWw+LCBTZXJ2aWNlQ2xhc3NUeXBlPFNlcnZpY2U+Pihtb2RlbC50eXBlIGFzIENsYXNzVHlwZTxNb2RlbD4sIHNlcnZpY2VUeXBlIGFzIFNlcnZpY2VDbGFzc1R5cGU8U2VydmljZT4pXG4gICAgICAgIDogbmV3IEVkaXRvckRhdGFQcm92aWRlckluc3Q8TW9kZWwsIHVuZGVmaW5lZCwgQ2xhc3NUeXBlPE1vZGVsPiwgdW5kZWZpbmVkPihtb2RlbC50eXBlIGFzIENsYXNzVHlwZTxNb2RlbD4sIHVuZGVmaW5lZCk7XG59XG4iXX0=
+/**
+ * Creates and returns an instance of `EditorDataProviderInst` with the specified options for managing editor data.
+ *
+ * @param {Object} [opts] - The options object to configure the data provider.
+ * @param {TypeDescriptor<Model> | ModelDescriptor<Model>} [opts.type] - The descriptor defining the type of model.
+ * @param {ServiceClassType<Service>} [opts.service] - The service class type associated with the data provider.
+ * @param {TypeDescriptor<CreateModel> | ModelDescriptor<CreateModel>} [opts.createType] - The descriptor defining the create type.
+ * @param {TypeDescriptor<UpdateModel> | ModelDescriptor<UpdateModel>} [opts.updateType] - The descriptor defining the update type.
+ * @return {EditorDataProviderInst<Model, Service, ServiceClass, CreateModel, UpdateModel>} An instance of `EditorDataProviderInst` configured according to the provided options.
+ */
+export function editorDataProvider(opts) {
+    return new EditorDataProviderInst(opts?.service);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tableview/api/editor/data-providers/editor.data-provider.mjs

@@ -1,10 +1,9 @@
-import { Subject, throwError } from 'rxjs';
-import { CommonsInternalError, DataProviderInst } from '@mediusinc/mng-commons/core';
+import { Subject } from 'rxjs';
+import { DataProviderInst } from '@mediusinc/mng-commons/core';
 export class EditorDataProviderInst extends DataProviderInst {
-    constructor(type, serviceType) {
-        super(type, serviceType);
+    constructor(serviceType) {
+        super(serviceType);
         this._editorResetSubject = new Subject();
-        this._fetch = id => throwError(() => new CommonsInternalError(`No fetch function provided for id ${id}.`));
     }
     get fetch() {
         return this._fetch;
@@ -18,6 +17,12 @@ export class EditorDataProviderInst extends DataProviderInst {
     get delete() {
         return this._delete;
     }
+    get mapFetchItemToCreateItem() {
+        return this._mapFetchItemToCreateItem;
+    }
+    get mapFetchItemToUpdateItem() {
+        return this._mapFetchItemToUpdateItem;
+    }
     get editorReset$() {
         return this._editorResetSubject.asObservable();
     }
@@ -37,7 +42,7 @@ export class EditorDataProviderInst extends DataProviderInst {
     /**
      * Sets the create function for the EditorDataProvider.
      *
-     * @param {EditorDataProviderCreateFnType<Model, Service>} fn - The function used for creating new items.
+     * @param {EditorDataProviderCreateFnType<CreateModel, Model, Service>} fn - The function used for creating new items.
      * @returns {this} - Returns the instance of the class.
      *
      * @typeparam Model The type of data this DataProvider will handle.
@@ -74,8 +79,36 @@ export class EditorDataProviderInst extends DataProviderInst {
         this._delete = fn;
         return this;
     }
+    /**
+     * Sets the function to map data from fetch function to create model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, CreateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam CreateModel The type of data to map to.
+     */
+    withMapFetchItemToCreateItem(fn) {
+        this._mapFetchItemToCreateItem = fn;
+        return this;
+    }
+    /**
+     * Sets the function to map data from fetch function to update model.
+     *
+     * @param {EditorDataProviderFetchMapToFnType<Model, UpdateModel>} fn - The map function to be set.
+     *
+     * @returns {this} - Returns the instance of the current class.
+     *
+     * @typeparam Model The type of data from fetch function to map from.
+     * @typeparam UpdateModel The type of data to map to.
+     */
+    withMapFetchItemToUpdateItem(fn) {
+        this._mapFetchItemToUpdateItem = fn;
+        return this;
+    }
     resetEditor(event) {
         this._editorResetSubject.next(event ?? {});
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.data-provider.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/editor/data-providers/editor.data-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,OAAO,EAAE,UAAU,EAAC,MAAM,MAAM,CAAC;AAErD,OAAO,EAAe,oBAAoB,EAAE,gBAAgB,EAA+D,MAAM,6BAA6B,CAAC;AAiE/J,MAAM,OAAO,sBACT,SAAQ,gBAA0D;IAUlE,YAAmB,IAAgB,EAAE,WAAyB;QAC1D,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QARV,wBAAmB,GAAG,IAAI,OAAO,EAA2B,CAAC;QAEtE,WAAM,GAAkD,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,oBAAoB,CAAC,qCAAqC,EAAE,GAAG,CAAC,CAAC,CAAC;IAO/J,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC;IACnD,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAiD;QACvD,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAmD;QAC1D,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAmD;QAC1D,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAmD;QAC1D,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,WAAW,CAAC,KAA+B;QACvC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IAC/C,CAAC;CACJ","sourcesContent":["import {Observable, Subject, throwError} from 'rxjs';\n\nimport {ClassOptType, CommonsInternalError, DataProviderInst, IDataProvider, IdType, ItemOrObservable, ServiceClassOptType} from '@mediusinc/mng-commons/core';\n\nimport {EditorResetEvent} from '../models/form-editor.event';\n\nexport type EditorDataProviderFetchFnType<Model = any, Service = undefined, Id = IdType, Return = ItemOrObservable<Model>> = (\n    id: Id,\n    service: Service,\n    locale: string | undefined\n) => Return;\nexport type EditorDataProviderCreateFnType<Model = any, Service = undefined, Item = Model | undefined, Return = ItemOrObservable<Model>> = (item: Item, service: Service) => Return;\nexport type EditorDataProviderUpdateFnType<Model = any, Service = undefined, Id = IdType, Item = Model | undefined, Return = ItemOrObservable<Model>> = (\n    id: Id,\n    item: Item,\n    service: Service\n) => Return;\nexport type EditorDataProviderDeleteFnType<Model = any, Service = undefined, Id = IdType, Item = Model | undefined, Return = ItemOrObservable<Model | null>> = (\n    id: Id,\n    item: Item,\n    service: Service\n) => Return;\n\nexport interface IEditorDataProviderFetch<Model, Service> {\n    fetch: EditorDataProviderFetchFnType<Model, Service>;\n\n    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;\n}\n\nexport interface IEditorDataProviderCreate<Model, Service> {\n    create?: EditorDataProviderCreateFnType<Model, Service>;\n\n    withCreate(fn?: EditorDataProviderCreateFnType<Model, Service>): this;\n}\n\nexport interface IEditorDataProviderUpdate<Model, Service> {\n    update?: EditorDataProviderUpdateFnType<Model, Service>;\n\n    withUpdate(fn?: EditorDataProviderUpdateFnType<Model, Service>): this;\n}\n\nexport interface IEditorDataProviderDelete<Model, Service> {\n    delete?: EditorDataProviderDeleteFnType<Model, Service>;\n\n    withDelete(fn?: EditorDataProviderDeleteFnType<Model, Service>): this;\n}\n\nexport type IEditorDataProviderFnsType<Model, Service> = IEditorDataProviderFetch<Model, Service> &\n    IEditorDataProviderCreate<Model, Service> &\n    IEditorDataProviderUpdate<Model, Service> &\n    IEditorDataProviderDelete<Model, Service>;\n\nexport interface IEditorDataProviderSupport<Model> {\n    get editorReset$(): Observable<EditorResetEvent<Model>>;\n\n    resetEditor(event?: EditorResetEvent<Model>): void;\n}\n\nexport type IEditorDataProvider<Model = any, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IDataProvider<\n    Model,\n    Service,\n    ModelClass,\n    ServiceClass\n> &\n    IEditorDataProviderFnsType<Model, Service> &\n    IEditorDataProviderSupport<Model>;\n\nexport class EditorDataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>>\n    extends DataProviderInst<Model, Service, ModelClass, ServiceClass>\n    implements IEditorDataProvider<Model, Service, ModelClass, ServiceClass>\n{\n    protected readonly _editorResetSubject = new Subject<EditorResetEvent<Model>>();\n\n    protected _fetch: EditorDataProviderFetchFnType<Model, Service> = id => throwError(() => new CommonsInternalError(`No fetch function provided for id ${id}.`));\n    protected _create?: EditorDataProviderCreateFnType<Model, Service>;\n    protected _update?: EditorDataProviderUpdateFnType<Model, Service>;\n    protected _delete?: EditorDataProviderDeleteFnType<Model, Service>;\n\n    public constructor(type: ModelClass, serviceType: ServiceClass) {\n        super(type, serviceType);\n    }\n\n    get fetch() {\n        return this._fetch;\n    }\n\n    get create() {\n        return this._create;\n    }\n\n    get update() {\n        return this._update;\n    }\n\n    get delete() {\n        return this._delete;\n    }\n\n    get editorReset$() {\n        return this._editorResetSubject.asObservable();\n    }\n\n    /**\n     * Sets the fetch function for the EditorDataProvider instance.\n     *\n     * @param {EditorDataProviderFetchFnType<Model, Service>} fn - The fetch function to be set.\n     * @returns {this} - The instance of the EditorDataProvider with the fetch function set.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this {\n        this._fetch = fn;\n        return this;\n    }\n\n    /**\n     * Sets the create function for the EditorDataProvider.\n     *\n     * @param {EditorDataProviderCreateFnType<Model, Service>} fn - The function used for creating new items.\n     * @returns {this} - Returns the instance of the class.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withCreate(fn?: EditorDataProviderCreateFnType<Model, Service>): this {\n        this._create = fn;\n        return this;\n    }\n\n    /**\n     * Sets the update function for the EditorDataProvider.\n     *\n     * @param {EditorDataProviderUpdateFnType<Model, Service>} fn - The update function to be set.\n     * @returns {this} - Returns the instance of the object calling this method.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withUpdate(fn?: EditorDataProviderUpdateFnType<Model, Service>): this {\n        this._update = fn;\n        return this;\n    }\n\n    /**\n     * Sets the delete function for the editor data provider.\n     *\n     * @param {EditorDataProviderDeleteFnType<Model, Service>} fn - The delete function to be set.\n     *\n     * @returns {this} - Returns the instance of the current class.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withDelete(fn?: EditorDataProviderDeleteFnType<Model, Service>): this {\n        this._delete = fn;\n        return this;\n    }\n\n    resetEditor(event?: EditorResetEvent<Model>): void {\n        this._editorResetSubject.next(event ?? {});\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor.data-provider.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/editor/data-providers/editor.data-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,OAAO,EAAC,MAAM,MAAM,CAAC;AAEzC,OAAO,EAAC,gBAAgB,EAA0E,MAAM,6BAA6B,CAAC;AAqFtI,MAAM,OAAO,sBACT,SAAQ,gBAA8C;IAYtD,YAAmB,WAAyB;QACxC,KAAK,CAAC,WAAW,CAAC,CAAC;QAVJ,wBAAmB,GAAG,IAAI,OAAO,EAA2B,CAAC;IAWhF,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,IAAI,wBAAwB;QACxB,OAAO,IAAI,CAAC,yBAAyB,CAAC;IAC1C,CAAC;IAED,IAAI,wBAAwB;QACxB,OAAO,IAAI,CAAC,yBAAyB,CAAC;IAC1C,CAAC;IAED,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC;IACnD,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAiD;QACvD,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAgE;QACvE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAgE;QACvE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;;OASG;IACH,UAAU,CAAmB,EAAyD;QAClF,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;;OASG;IACH,4BAA4B,CAAC,EAA2D;QACpF,IAAI,CAAC,yBAAyB,GAAG,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;;;OASG;IACH,4BAA4B,CAAC,EAA2D;QACpF,IAAI,CAAC,yBAAyB,GAAG,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,WAAW,CAAC,KAA+B;QACvC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IAC/C,CAAC;CACJ","sourcesContent":["import {Observable, Subject} from 'rxjs';\n\nimport {DataProviderInst, IDataProvider, IdType, ItemOrObservable, ServiceClassOptType, Undefined} from '@mediusinc/mng-commons/core';\n\nimport {EditorResetEvent} from '../models/form-editor.event';\n\nexport type EditorDataProviderFetchFnType<Model = any, Service = undefined, Id = IdType, Return = ItemOrObservable<Model>> = (\n    id: Id,\n    service: Service,\n    locale: string | undefined\n) => Return;\nexport type EditorDataProviderCreateFnType<CreateModel = any, Model = any, Service = undefined, Item = Undefined<CreateModel>, Return = ItemOrObservable<Undefined<Model>>> = (\n    item: Item,\n    service: Service\n) => Return;\nexport type EditorDataProviderUpdateFnType<\n    UpdateModel = any,\n    Model = any,\n    Service = undefined,\n    Id = IdType,\n    Item = Undefined<UpdateModel>,\n    Return = ItemOrObservable<Undefined<Model>>\n> = (id: Id, item: Item, service: Service) => Return;\nexport type EditorDataProviderDeleteFnType<Model = any, Service = undefined, Item = undefined, Id = IdType, Return = ItemOrObservable<Undefined<Model>>> = (\n    id: Id,\n    service: Service,\n    item: Item\n) => Return;\nexport type EditorDataProviderFetchMapToFnType<FromModel, ToModel> = (item: FromModel) => ToModel;\n\nexport interface IEditorDataProviderFetch<Model, Service> {\n    fetch?: EditorDataProviderFetchFnType<Model, Service>;\n\n    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this;\n}\n\nexport interface IEditorDataProviderCreate<CreateModel, Model, Service> {\n    create?: EditorDataProviderCreateFnType<CreateModel, Model, Service>;\n\n    withCreate(fn?: EditorDataProviderCreateFnType<CreateModel, Model, Service>): this;\n}\n\nexport interface IEditorDataProviderUpdate<UpdateModel, Model, Service> {\n    update?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>;\n\n    withUpdate(fn?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>): this;\n}\n\nexport interface IEditorDataProviderDelete<Model, Service> {\n    delete?: EditorDataProviderDeleteFnType<Model, Service, any>;\n\n    withDelete<Item = undefined>(fn?: EditorDataProviderDeleteFnType<Model, Service, Item>): this;\n}\n\nexport interface IEditorDataProviderFetchMapToCreate<Model, CreateModel> {\n    mapFetchItemToCreateItem?: EditorDataProviderFetchMapToFnType<Model, CreateModel>;\n\n    withMapFetchItemToCreateItem(fn?: EditorDataProviderFetchMapToFnType<Model, CreateModel>): this;\n}\n\nexport interface IEditorDataProviderFetchMapToUpdate<Model, UpdateModel> {\n    mapFetchItemToUpdateItem?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>;\n\n    withMapFetchItemToUpdateItem(fn?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>): this;\n}\n\nexport type IEditorDataProviderFnsType<Model, Service, CreateModel = Model, UpdateModel = Model, DeleteModel = Model> = IEditorDataProviderFetch<Model, Service> &\n    IEditorDataProviderCreate<CreateModel, Model, Service> &\n    IEditorDataProviderUpdate<UpdateModel, Model, Service> &\n    IEditorDataProviderDelete<DeleteModel, Service> &\n    IEditorDataProviderFetchMapToCreate<Model, CreateModel> &\n    IEditorDataProviderFetchMapToUpdate<Model, UpdateModel>;\n\nexport interface IEditorDataProviderSupport<Model> {\n    get editorReset$(): Observable<EditorResetEvent<Model>>;\n\n    resetEditor(event?: EditorResetEvent<Model>): void;\n}\n\nexport type IEditorDataProvider<Model = any, Service = any, ServiceClass = ServiceClassOptType<Service>, CreateModel = Model, UpdateModel = Model> = IDataProvider<\n    Model,\n    Service,\n    ServiceClass\n> &\n    IEditorDataProviderFnsType<Model, Service, CreateModel, UpdateModel> &\n    IEditorDataProviderSupport<Model>;\n\nexport class EditorDataProviderInst<Model, Service = any, ServiceClass = ServiceClassOptType<Service>, CreateModel = Model, UpdateModel = Model>\n    extends DataProviderInst<Model, Service, ServiceClass>\n    implements IEditorDataProvider<Model, Service, ServiceClass, CreateModel, UpdateModel>\n{\n    protected readonly _editorResetSubject = new Subject<EditorResetEvent<Model>>();\n\n    protected _fetch?: EditorDataProviderFetchFnType<Model, Service>;\n    protected _create?: EditorDataProviderCreateFnType<CreateModel, Model, Service>;\n    protected _update?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>;\n    protected _delete?: EditorDataProviderDeleteFnType<Model, Service, any>;\n    protected _mapFetchItemToCreateItem?: EditorDataProviderFetchMapToFnType<Model, CreateModel>;\n    protected _mapFetchItemToUpdateItem?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>;\n\n    public constructor(serviceType: ServiceClass) {\n        super(serviceType);\n    }\n\n    get fetch() {\n        return this._fetch;\n    }\n\n    get create() {\n        return this._create;\n    }\n\n    get update() {\n        return this._update;\n    }\n\n    get delete() {\n        return this._delete;\n    }\n\n    get mapFetchItemToCreateItem() {\n        return this._mapFetchItemToCreateItem;\n    }\n\n    get mapFetchItemToUpdateItem() {\n        return this._mapFetchItemToUpdateItem;\n    }\n\n    get editorReset$() {\n        return this._editorResetSubject.asObservable();\n    }\n\n    /**\n     * Sets the fetch function for the EditorDataProvider instance.\n     *\n     * @param {EditorDataProviderFetchFnType<Model, Service>} fn - The fetch function to be set.\n     * @returns {this} - The instance of the EditorDataProvider with the fetch function set.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withFetch(fn: EditorDataProviderFetchFnType<Model, Service>): this {\n        this._fetch = fn;\n        return this;\n    }\n\n    /**\n     * Sets the create function for the EditorDataProvider.\n     *\n     * @param {EditorDataProviderCreateFnType<CreateModel, Model, Service>} fn - The function used for creating new items.\n     * @returns {this} - Returns the instance of the class.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withCreate(fn?: EditorDataProviderCreateFnType<CreateModel, Model, Service>): this {\n        this._create = fn;\n        return this;\n    }\n\n    /**\n     * Sets the update function for the EditorDataProvider.\n     *\n     * @param {EditorDataProviderUpdateFnType<Model, Service>} fn - The update function to be set.\n     * @returns {this} - Returns the instance of the object calling this method.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withUpdate(fn?: EditorDataProviderUpdateFnType<UpdateModel, Model, Service>): this {\n        this._update = fn;\n        return this;\n    }\n\n    /**\n     * Sets the delete function for the editor data provider.\n     *\n     * @param {EditorDataProviderDeleteFnType<Model, Service>} fn - The delete function to be set.\n     *\n     * @returns {this} - Returns the instance of the current class.\n     *\n     * @typeparam Model The type of data this DataProvider will handle.\n     * @typeparam Service The type of service used by this DataProvider.\n     */\n    withDelete<Item = undefined>(fn?: EditorDataProviderDeleteFnType<Model, Service, Item>): this {\n        this._delete = fn;\n        return this;\n    }\n\n    /**\n     * Sets the function to map data from fetch function to create model.\n     *\n     * @param {EditorDataProviderFetchMapToFnType<Model, CreateModel>} fn - The map function to be set.\n     *\n     * @returns {this} - Returns the instance of the current class.\n     *\n     * @typeparam Model The type of data from fetch function to map from.\n     * @typeparam CreateModel The type of data to map to.\n     */\n    withMapFetchItemToCreateItem(fn?: EditorDataProviderFetchMapToFnType<Model, CreateModel>): this {\n        this._mapFetchItemToCreateItem = fn;\n        return this;\n    }\n\n    /**\n     * Sets the function to map data from fetch function to update model.\n     *\n     * @param {EditorDataProviderFetchMapToFnType<Model, UpdateModel>} fn - The map function to be set.\n     *\n     * @returns {this} - Returns the instance of the current class.\n     *\n     * @typeparam Model The type of data from fetch function to map from.\n     * @typeparam UpdateModel The type of data to map to.\n     */\n    withMapFetchItemToUpdateItem(fn?: EditorDataProviderFetchMapToFnType<Model, UpdateModel>): this {\n        this._mapFetchItemToUpdateItem = fn;\n        return this;\n    }\n\n    resetEditor(event?: EditorResetEvent<Model>): void {\n        this._editorResetSubject.next(event ?? {});\n    }\n}\n"]}

package/esm2022/tableview/api/editor/descriptors/editor-descriptor.factory.mjs

@@ -1,81 +1,15 @@
-import { ModelDescriptor, TypeDescriptor, model } from '@mediusinc/mng-commons/model';
-import { getEditorClassAttributeDef } from '../helpers/class-attribute-converter';
-import { upsertEditorFieldFromAttributeDef } from '../helpers/editor-descriptor-helpers';
-import { TableviewEditorTypeEnum } from '../models/editor.model';
+import { ModelDescriptor, model } from '@mediusinc/mng-commons/model';
 import { EditorDescriptorInst } from './editor.descriptor';
-export class EditorDescriptor extends EditorDescriptorInst {
-    constructor() {
-        super(ModelDescriptor.create());
-    }
-    static create(idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return editorDescriptor({ id: idProperty, title: titleProperty, i18nBase: i18nBaseKey, tableviewEditorType: tableviewEditorType });
-    }
-    static fromClass(type, idProperty, titleProperty, i18nBaseKey, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return editorDescriptorFromClass(type, {
-            id: idProperty,
-            title: titleProperty,
-            i18nBase: i18nBaseKey,
-            tableviewEditorType: tableviewEditorType
-        });
-    }
-    static fromModel(model, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return editorDescriptor(model, { tableviewEditorType: 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, getEditorClassAttributeDef(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 tableviewEditorType Type of editor in tableview (add, edit, view or none).
-     */
-    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty, tableviewEditorType = TableviewEditorTypeEnum.None) {
-        return editorDescriptorFromClassAttrsDef(type, attributes, {
-            id: idProperty,
-            title: titleProperty,
-            tableviewEditorType: tableviewEditorType
-        });
-    }
-}
-export function editorDescriptor(typeOrModelOrClassOrOpts, opts) {
-    if (typeOrModelOrClassOrOpts == null) {
+export function editorDescriptor(modelOrOpts, opts) {
+    if (modelOrOpts == null) {
         return new EditorDescriptorInst(model(), opts?.tableviewEditorType);
     }
-    else if (typeOrModelOrClassOrOpts instanceof TypeDescriptor) {
-        return new EditorDescriptorInst(model(opts ?? {}), opts?.tableviewEditorType);
-    }
-    else if (typeOrModelOrClassOrOpts instanceof ModelDescriptor) {
-        return new EditorDescriptorInst(typeOrModelOrClassOrOpts, opts?.tableviewEditorType);
+    else if (modelOrOpts instanceof ModelDescriptor) {
+        return new EditorDescriptorInst(modelOrOpts, opts?.tableviewEditorType);
     }
     else {
         // this could have autoGenerated if model descriptor is class
-        return new EditorDescriptorInst(model(typeOrModelOrClassOrOpts), typeOrModelOrClassOrOpts?.tableviewEditorType);
+        return new EditorDescriptorInst(model(modelOrOpts), modelOrOpts?.tableviewEditorType);
     }
 }
-export function editorDescriptorFromClass(type, opts) {
-    return new EditorDescriptorInst(model(type, opts), opts?.tableviewEditorType);
-}
-/**
- * Generates descriptor based on type attribute definition
- * @param type class type
- * @param attributes
- * @param opts
- */
-export function editorDescriptorFromClassAttrsDef(type, attributes, opts) {
-    const descriptor = new EditorDescriptorInst(model(type, opts), opts?.tableviewEditorType);
-    (attributes ?? getEditorClassAttributeDef(type))
-        .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
-        .forEach(attr => upsertEditorFieldFromAttributeDef(descriptor, attr));
-    return descriptor;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-descriptor.factory.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/editor/descriptors/editor-descriptor.factory.ts"],"names":[],"mappings":"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","sourcesContent":["import {ClassType} from '@mediusinc/mng-commons/core';\nimport {ModelDescriptor, ModelDescriptorCreateOpts, TypeDescriptor, model} from '@mediusinc/mng-commons/model';\n\nimport {getEditorClassAttributeDef} from '../helpers/class-attribute-converter';\nimport {upsertEditorFieldFromAttributeDef} from '../helpers/editor-descriptor-helpers';\nimport {EditorClassAttributeDef} from '../models/class-tableview-attribute.model';\nimport {TableviewEditorTypeEnum} from '../models/editor.model';\nimport {EditorDescriptorInst} from './editor.descriptor';\n\nexport class EditorDescriptor extends EditorDescriptorInst<any> {\n    protected constructor() {\n        super(ModelDescriptor.create());\n    }\n\n    public static create<EditorModel, ParentEditorModel = undefined>(\n        idProperty?: keyof EditorModel,\n        titleProperty?: keyof EditorModel,\n        i18nBaseKey?: string | ClassType<unknown>,\n        tableviewEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel, ParentEditorModel> {\n        return editorDescriptor<EditorModel, ParentEditorModel>({id: idProperty, title: titleProperty, i18nBase: i18nBaseKey, tableviewEditorType: tableviewEditorType});\n    }\n\n    public static fromClass<EditorModel, ParentEditorModel = undefined>(\n        type: ClassType<EditorModel>,\n        idProperty?: keyof EditorModel,\n        titleProperty?: keyof EditorModel,\n        i18nBaseKey?: ClassType<unknown> | string,\n        tableviewEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel, ParentEditorModel> {\n        return editorDescriptorFromClass<EditorModel, ParentEditorModel>(type, {\n            id: idProperty,\n            title: titleProperty,\n            i18nBase: i18nBaseKey,\n            tableviewEditorType: tableviewEditorType\n        });\n    }\n\n    public static fromModel<EditorModel, ParentEditorModel = undefined>(\n        model: ModelDescriptor<EditorModel>,\n        tableviewEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel, ParentEditorModel> {\n        return editorDescriptor<EditorModel, ParentEditorModel>(model, {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 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, ParentEditorModel = undefined>(\n        type: ClassType<EditorModel>,\n        idProperty?: keyof EditorModel,\n        titleProperty?: keyof EditorModel,\n        tableEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel, ParentEditorModel> {\n        return EditorDescriptor.fromClassWithCustomAttrsDef<EditorModel, ParentEditorModel>(type, getEditorClassAttributeDef(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 tableviewEditorType Type of editor in tableview (add, edit, view or none).\n     */\n    public static fromClassWithCustomAttrsDef<EditorModel, ParentEditorModel = undefined>(\n        type: ClassType<EditorModel>,\n        attributes: EditorClassAttributeDef[],\n        idProperty?: keyof EditorModel,\n        titleProperty?: keyof EditorModel,\n        tableviewEditorType = TableviewEditorTypeEnum.None\n    ): EditorDescriptorInst<EditorModel, ParentEditorModel> {\n        return editorDescriptorFromClassAttrsDef<EditorModel, ParentEditorModel>(type, attributes, {\n            id: idProperty,\n            title: titleProperty,\n            tableviewEditorType: tableviewEditorType\n        });\n    }\n}\n\nexport type EditorDescriptorCreateBaseOptsType = {\n    tableviewEditorType?: TableviewEditorTypeEnum;\n};\nexport type EditorDescriptorCreateOptsType<EditorModel> = ModelDescriptorCreateOpts<EditorModel> & EditorDescriptorCreateBaseOptsType;\n\nexport function editorDescriptor<EditorModel, ParentEditorModel = undefined>(): EditorDescriptorInst<EditorModel, ParentEditorModel>;\nexport function editorDescriptor<EditorModel, ParentEditorModel = undefined>(\n    opts: EditorDescriptorCreateOptsType<EditorModel>\n): EditorDescriptorInst<EditorModel, ParentEditorModel>;\nexport function editorDescriptor<EditorModel, ParentEditorModel = undefined>(\n    model: ModelDescriptor<EditorModel>,\n    opts?: EditorDescriptorCreateBaseOptsType\n): EditorDescriptorInst<EditorModel, ParentEditorModel>;\nexport function editorDescriptor<EditorModel, ParentEditorModel = undefined>(\n    type: TypeDescriptor<EditorModel>,\n    opts?: EditorDescriptorCreateOptsType<EditorModel>\n): EditorDescriptorInst<EditorModel, ParentEditorModel>;\nexport function editorDescriptor<EditorModel, ParentEditorModel = undefined>(\n    typeOrModelOrClassOrOpts?: TypeDescriptor<EditorModel> | ModelDescriptor<EditorModel> | EditorDescriptorCreateOptsType<EditorModel>,\n    opts?: EditorDescriptorCreateOptsType<EditorModel>\n) {\n    if (typeOrModelOrClassOrOpts == null) {\n        return new EditorDescriptorInst<EditorModel, ParentEditorModel>(model<EditorModel>(), opts?.tableviewEditorType);\n    } else if (typeOrModelOrClassOrOpts instanceof TypeDescriptor) {\n        return new EditorDescriptorInst<EditorModel, ParentEditorModel>(\n            model<EditorModel>((opts as EditorDescriptorCreateOptsType<EditorModel> | undefined) ?? {}),\n            opts?.tableviewEditorType\n        );\n    } else if (typeOrModelOrClassOrOpts instanceof ModelDescriptor) {\n        return new EditorDescriptorInst<EditorModel, ParentEditorModel>(typeOrModelOrClassOrOpts, opts?.tableviewEditorType);\n    } else {\n        // this could have autoGenerated if model descriptor is class\n        return new EditorDescriptorInst<EditorModel, ParentEditorModel>(model<EditorModel>(typeOrModelOrClassOrOpts), typeOrModelOrClassOrOpts?.tableviewEditorType);\n    }\n}\n\nexport function editorDescriptorFromClass<EditorModel, ParentEditorModel = undefined>(\n    type: ClassType<EditorModel>,\n    opts?: EditorDescriptorCreateOptsType<EditorModel>\n): EditorDescriptorInst<EditorModel, ParentEditorModel> {\n    return new EditorDescriptorInst<EditorModel, ParentEditorModel>(model<EditorModel>(type as ClassType<EditorModel>, opts), opts?.tableviewEditorType);\n}\n\n/**\n * Generates descriptor based on type attribute definition\n * @param type class type\n * @param attributes\n * @param opts\n */\nexport function editorDescriptorFromClassAttrsDef<EditorModel, ParentEditorModel = undefined>(\n    type: ClassType<EditorModel>,\n    attributes?: EditorClassAttributeDef[],\n    opts?: EditorDescriptorCreateOptsType<EditorModel>\n): EditorDescriptorInst<EditorModel, ParentEditorModel> {\n    const descriptor = new EditorDescriptorInst<EditorModel, ParentEditorModel>(model(type, opts), opts?.tableviewEditorType);\n    (attributes ?? getEditorClassAttributeDef(type))\n        .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))\n        .forEach(attr => upsertEditorFieldFromAttributeDef(descriptor, attr));\n    return descriptor;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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