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

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

@@ -1,4 +1,8 @@
-import { createTableviewActions, getTableviewDefaultActions } from './tableview-default-actions';
+import { CommonsInternalError } from '@mediusinc/mng-commons/core';
+import { ActionPositionEnum } from '../../action/models/action.type';
+import { TableviewActionDefaultCategories } from '../../action/models/tableview-action-default-categories.model';
+import { TableviewDataProviderInst } from '../data-providers/tableview.data-provider';
+import { tableviewCreateDefaultActions, tableviewGetDefaultActions } from './tableview-default-actions';
 /**
  * The `TableviewBuilder` class is used to build a tableview configuration.
  * It allows you to set various options such as the descriptor, data provider,
@@ -16,7 +20,7 @@ export class TableviewInputBuilder {
         this._descriptor = _descriptor;
         this._dataProvider = _dataProvider;
         this.injector = injector;
-        this.defaultActions = getTableviewDefaultActions().map(a => ({ type: a, descriptor: undefined }));
+        this.defaultActions = tableviewGetDefaultActions().map(a => ({ type: a, descriptor: undefined }));
         this._customActions = [];
     }
     prepareSetterParams() {
@@ -72,6 +76,73 @@ export class TableviewInputBuilder {
         adjustFn(this.prepareSetterParams());
         return this;
     }
+    /**
+     * Associates a fetch function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the fetch API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of fetch function on API service.
+     */
+    withDataServiceFetchFn(serviceFn, itemIdParamName) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withFetch((itemId, service) => service[serviceFn]({ [itemIdParamName]: itemId }));
+        }
+        return this;
+    }
+    /**
+     * Associates a create function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the create API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} serviceFnItemParamName The parameter name for item used as the key within the request object of create function on API service.
+     * @param {EditorDataProviderFetchMapToFnType<Model, AddModel>} [mapFetchItem] Map function to transform model from fetch to form's add model.
+     */
+    withDataServiceCreateFn(serviceFn, serviceFnItemParamName, mapFetchItem) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withCreate((item, service) => service[serviceFn]({ [serviceFnItemParamName]: item }));
+            if (mapFetchItem) {
+                this._dataProvider.withMapFetchItemToCreateItem(mapFetchItem);
+            }
+        }
+        return this;
+    }
+    /**
+     * Associates an update function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the update API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} fnItemParamName The parameter name for item used as the key within the request object of update function on API service.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} [fnItemIdParamName] The parameter name for itemId used as the key within the request object of update function on API service.
+     * @param {EditorDataProviderFetchMapToFnType<Model, EditModel>} [mapFetchItem] Map function to transform model from fetch to form' edit model.
+     */
+    withDataServiceUpdateFn(serviceFn, fnItemParamName, fnItemIdParamName, mapFetchItem) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withUpdate((id, item, service) => {
+                const params = { [fnItemParamName]: item };
+                if (fnItemIdParamName) {
+                    params[fnItemIdParamName] = id;
+                }
+                return service[serviceFn](params);
+            });
+            if (mapFetchItem) {
+                this._dataProvider.withMapFetchItemToUpdateItem(mapFetchItem);
+            }
+        }
+        return this;
+    }
+    /**
+     * Associates a delete function for a data provider API service with the specified parameters.
+     *
+     * @param {ServiceFn} serviceFn The function from the service class that performs the delete API call.
+     *                              Must be a key of the service with a parameter and return an Observable.
+     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of delete function on API service.
+     */
+    withDataServiceDeleteFn(serviceFn, fnItemIdParamName) {
+        if (this._dataProvider instanceof TableviewDataProviderInst) {
+            this._dataProvider.withDelete((itemId, service) => service[serviceFn]({ [fnItemIdParamName]: itemId }));
+        }
+        return this;
+    }
     /**
      * Removes all the default tableview actions.
      *
@@ -115,7 +186,7 @@ export class TableviewInputBuilder {
      * Overrides the default action.
      *
      * @param {TableviewDefaultActionsEnum} type - The default actions to override.
-     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {TvBuilderActionSetterFnType<Model, ActionService , ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
      * @typeParam ActionService - The service type (same as build `Service` by default).
      * @returns {this} - Returns the current instance of the builder.
      */
@@ -129,7 +200,9 @@ export class TableviewInputBuilder {
     /**
      * Adds a custom action.
      *
-     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @deprecated Use on of {withActionOnTable}, {withActionOnDetailsEditor}, {withActionOnEditEditor} or {withActionOnAddEditor} instead.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
      * @typeParam ActionService - The service type (same as build `Service` by default).
      * @returns {this} - Returns the current instance of the builder.
      */
@@ -141,14 +214,98 @@ export class TableviewInputBuilder {
         return this;
     }
     /**
+     * Adds a custom action on table row or top (header or toolbar).
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnTable(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.READ]);
+            if (![
+                ActionPositionEnum.ToolbarLeft,
+                ActionPositionEnum.ToolbarRight,
+                ActionPositionEnum.TableHeader,
+                ActionPositionEnum.RowInline,
+                ActionPositionEnum.RowClick
+            ].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on table (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action on details editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnDetailsEditor(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS]);
+            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on details (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action on edit editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnEditEditor(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.EDIT]);
+            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on edit (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action on add editor.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withActionOnAddEditor(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            action.withPositionTableviewCategories([TableviewActionDefaultCategories.ADD]);
+            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {
+                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on add (${action.position}), define valid position.`);
+            }
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * @internal
+     *
      * Builds and returns an instance of ITableview.
      * DO NOT CALL this within tableview create callback function!
      *
-     * @return {TableviewInput<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
+     * @return {TableviewInput<Model, Service, Sorts, Filters, TableModel, AddModel, EditModel, Descriptor, DataProvider>} - The built ITableview instance.
      */
     build() {
         return {
-            actions: createTableviewActions(this._descriptor, this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type), this.defaultActions
+            actions: tableviewCreateDefaultActions(this._descriptor, this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type), this.defaultActions
                 .filter(a => a.descriptor != null)
                 .reduce((acc, a) => ({
                 ...acc,
@@ -159,4 +316,4 @@ export class TableviewInputBuilder {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-input-builder.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/tableview/helpers/tableview-input-builder.ts"],"names":[],"mappings":"AAOA,OAAO,EAA8B,sBAAsB,EAAE,0BAA0B,EAAC,MAAM,6BAA6B,CAAC;AAc5H;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,qBAAqB;IAW9B,YACY,WAAuB,EACvB,aAA2B,EAClB,QAAkB;QAF3B,gBAAW,GAAX,WAAW,CAAY;QACvB,kBAAa,GAAb,aAAa,CAAc;QAClB,aAAQ,GAAR,QAAQ,CAAU;QAN/B,mBAAc,GAAoB,0BAA0B,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,SAAS,EAAC,CAAC,CAAC,CAAC;QACnG,mBAAc,GAAgC,EAAE,CAAC;IAM/D,CAAC;IAEI,mBAAmB;QACvB,OAAO,EAAC,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,YAAY,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAC,CAAC;IACrG,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,EAA6D;QACxE,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;QAClD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,oBAAoB,CAAC,QAA0C;QAC3D,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,EAA+D;QAC5E,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,sBAAsB,CAAC,QAA8C;QACjE,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,QAA+E;QACtF,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACH,oBAAoB;QAChB,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC;QACxD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,GAAG,KAAoC;QACtD,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACjB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YAC9D,IAAI,MAAM,EAAE,UAAU,KAAK,IAAI,EAAE,CAAC;gBAC9B,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;YAClC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,qBAAqB,CAAC,GAAG,KAAoC;QACzD,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACjB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YAC9D,IAAI,MAAM,EAAE,CAAC;gBACT,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC;YAC7B,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;;OAOG;IACH,yBAAyB,CAA0B,IAAiC,EAAE,EAA+E;QACjK,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAC9D,IAAI,MAAM,EAAE,CAAC;YACT,MAAM,CAAC,UAAU,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,IAAI,IAAI,CAAC;QAC/D,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACH,UAAU,CAA+C,EAAqF;QAC1I,MAAM,MAAM,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;QAC9C,IAAI,MAAM,EAAE,CAAC;YACT,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACH,KAAK;QACD,OAAiF;YAC7E,OAAO,EAAE,sBAAsB,CAC3B,IAAI,CAAC,WAAqD,EAC1D,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EACvE,IAAI,CAAC,cAAc;iBACd,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC;iBACjC,MAAM,CACH,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBACT,GAAG,GAAG;gBACN,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,UAAW;aAC1B,CAAC,EACyC,EAAE,CAChD,EACL,IAAI,CAAC,QAAQ,CAChB,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC;YAC7B,YAAY,EAAE,IAAI,CAAC,aAAa;YAChC,UAAU,EAAE,IAAI,CAAC,WAAW;SAC/B,CAAC;IACN,CAAC;CACJ","sourcesContent":["import {Injector} from '@angular/core';\n\nimport {IDataProvider, Nullable} from '@mediusinc/mng-commons/core';\n\nimport {ActionDescriptorInst} from '../../action/descriptors/action.descriptor';\nimport {TableviewDescriptorInst} from '../descriptors/tableview.descriptor';\nimport {TableviewInput} from '../models/tableview-input.model';\nimport {TableviewDefaultActionsEnum, createTableviewActions, getTableviewDefaultActions} from './tableview-default-actions';\n\nexport type TvBuilderSetterParamsType<Descriptor, DataProvider> = {descriptor: Descriptor; dataProvider: DataProvider; injector: Injector};\nexport type TvBuilderActionSetterFnType<ActionModel, ActionService, Descriptor, DataProvider> = (\n    params: TvBuilderSetterParamsType<Descriptor, DataProvider>\n) => Nullable<ActionDescriptorInst<ActionModel, ActionService>>;\nexport type TvBuilderDescriptorSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Descriptor;\nexport type TvBuilderDataProviderSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => DataProvider;\n\ntype DefaultAction = {\n    type: TableviewDefaultActionsEnum;\n    descriptor: ActionDescriptorInst<any, any> | null | undefined;\n};\n\n/**\n * The `TableviewBuilder` class is used to build a tableview configuration.\n * It allows you to set various options such as the descriptor, data provider,\n * default actions, and custom actions for the tableview.\n *\n * @typeparam Model - The main model type.\n * @typeparam Service - The API service type.\n * @typeparam Descriptor - The descriptor type.\n * @typeparam DataProvider - The data provider type.\n * @typeparam Sorts - The sort type representing available sort keys.\n * @typeparam Filters - The filter type representing available filter keys.\n */\nexport class TableviewInputBuilder<\n    Model,\n    Service,\n    Descriptor extends TableviewDescriptorInst<Model, Sorts, Filters>,\n    DataProvider extends IDataProvider<Model, Service>,\n    Sorts = keyof Model,\n    Filters extends keyof any = keyof Model\n> {\n    private defaultActions: DefaultAction[] = getTableviewDefaultActions().map(a => ({type: a, descriptor: undefined}));\n    private readonly _customActions: ActionDescriptorInst<any>[] = [];\n\n    constructor(\n        private _descriptor: Descriptor,\n        private _dataProvider: DataProvider,\n        private readonly injector: Injector\n    ) {}\n\n    private prepareSetterParams(): TvBuilderSetterParamsType<Descriptor, DataProvider> {\n        return {descriptor: this._descriptor, dataProvider: this._dataProvider, injector: this.injector};\n    }\n\n    /**\n     * Sets a descriptor instead of the default one.\n     *\n     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDescriptor(fn: TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>): this {\n        this._descriptor = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the descriptor using the provided adjust function.\n     *\n     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDescriptor(adjustFn: (descriptor: Descriptor) => void): this {\n        adjustFn(this._descriptor);\n        return this;\n    }\n\n    /**\n     * Sets the data provider for the TvBuilder instance\n     *\n     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * * @returns {this} - Returns the current instance of the builder.\n     */\n    withDataProvider(fn: TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>): this {\n        this._dataProvider = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider using the provided adjust function.\n     *\n     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDataProvider(adjustFn: (dataProvider: DataProvider) => void): this {\n        adjustFn(this._dataProvider);\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider and/or descriptor using the provided adjust function.\n     *\n     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjust(adjustFn: (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void): this {\n        adjustFn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Removes all the default tableview actions.\n     *\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withNoDefaultActions(): this {\n        this.defaultActions.forEach(a => (a.descriptor = null));\n        return this;\n    }\n\n    /**\n     * Adds the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action?.descriptor === null) {\n                action.descriptor = undefined;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Removes the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withoutDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action) {\n                action.descriptor = null;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Overrides the default action.\n     *\n     * @param {TableviewDefaultActionsEnum} type - The default actions to override.\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActionOverride<ActionService = Service>(type: TableviewDefaultActionsEnum, fn: TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>): this {\n        const action = this.defaultActions.find(a => a.type === type);\n        if (action) {\n            action.descriptor = fn(this.prepareSetterParams()) ?? null;\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action.\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAction<ActionModel = Model, ActionService = Service>(fn: TvBuilderActionSetterFnType<ActionModel, ActionService, Descriptor, DataProvider>): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * Builds and returns an instance of ITableview.\n     * DO NOT CALL this within tableview create callback function!\n     *\n     * @return {TableviewInput<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.\n     */\n    build() {\n        return <TableviewInput<Model, Service, Sorts, Filters, Descriptor, DataProvider>>{\n            actions: createTableviewActions(\n                this._descriptor as TableviewDescriptorInst<any, any, any>,\n                this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type),\n                this.defaultActions\n                    .filter(a => a.descriptor != null)\n                    .reduce(\n                        (acc, a) => ({\n                            ...acc,\n                            [a.type]: a.descriptor!\n                        }),\n                        <Record<number, ActionDescriptorInst<any>>>{}\n                    ),\n                this.injector\n            ).concat(this._customActions),\n            dataProvider: this._dataProvider,\n            descriptor: this._descriptor\n        };\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-input-builder.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/tableview/helpers/tableview-input-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injector} from '@angular/core';\n\nimport {Observable} from 'rxjs';\n\nimport {\n    ClassFunctionKeyParam1ObjKeyExtendsOfTargetType,\n    ClassFunctionKeysWithParamAndReturnType,\n    CommonsInternalError,\n    IDataProvider,\n    IdType,\n    Nullable\n} from '@mediusinc/mng-commons/core';\n\nimport {ActionEditorDescriptorInst} from '../../action/descriptors/action-editor.descriptor';\nimport {ActionDescriptorInst} from '../../action/descriptors/action.descriptor';\nimport {ActionPositionEnum} from '../../action/models/action.type';\nimport {TableviewActionDefaultCategories} from '../../action/models/tableview-action-default-categories.model';\nimport {EditorDataProviderFetchMapToFnType} from '../../editor/data-providers/editor.data-provider';\nimport {TableviewDataProviderInst} from '../data-providers/tableview.data-provider';\nimport {TableviewDescriptorInst} from '../descriptors/tableview.descriptor';\nimport {TableviewInput} from '../models/tableview-input.model';\nimport {TableviewDefaultActionsEnum, tableviewCreateDefaultActions, tableviewGetDefaultActions} from './tableview-default-actions';\n\nexport type TvBuilderSetterParamsType<Descriptor, DataProvider> = {descriptor: Descriptor; dataProvider: DataProvider; injector: Injector};\nexport type TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ValidationInput, Descriptor, DataProvider> = (\n    params: TvBuilderSetterParamsType<Descriptor, DataProvider>\n) => Nullable<\n    | ActionDescriptorInst<ActionModel, ActionService, ActionInput, ActionResult, ValidationInput>\n    | ActionEditorDescriptorInst<ActionModel, ActionService, any, ActionInput, ActionResult, ValidationInput>\n>;\nexport type TvBuilderDescriptorSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Descriptor;\nexport type TvBuilderDataProviderSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => DataProvider;\n\ntype DefaultAction = {\n    type: TableviewDefaultActionsEnum;\n    descriptor: ActionDescriptorInst<any> | null | undefined;\n};\n\n/**\n * The `TableviewBuilder` class is used to build a tableview configuration.\n * It allows you to set various options such as the descriptor, data provider,\n * default actions, and custom actions for the tableview.\n *\n * @typeparam Model - The main model type.\n * @typeparam Service - The API service type.\n * @typeparam Descriptor - The descriptor type.\n * @typeparam DataProvider - The data provider type.\n * @typeparam Sorts - The sort type representing available sort keys.\n * @typeparam Filters - The filter type representing available filter keys.\n */\nexport class TableviewInputBuilder<\n    Model,\n    Service,\n    Descriptor extends TableviewDescriptorInst<Model, Sorts, Filters, undefined, TableModel, AddModel, EditModel, FieldsModel>,\n    DataProvider extends IDataProvider<Model, Service>,\n    Sorts = keyof Model,\n    Filters extends keyof any = keyof Model,\n    TableModel = Model,\n    AddModel = Model,\n    EditModel = Model,\n    FieldsModel = Model\n> {\n    private defaultActions: DefaultAction[] = tableviewGetDefaultActions().map(a => ({type: a, descriptor: undefined}));\n    private readonly _customActions: ActionDescriptorInst<any>[] = [];\n\n    constructor(\n        private _descriptor: Descriptor,\n        private _dataProvider: DataProvider,\n        private readonly injector: Injector\n    ) {}\n\n    private prepareSetterParams(): TvBuilderSetterParamsType<Descriptor, DataProvider> {\n        return {descriptor: this._descriptor, dataProvider: this._dataProvider, injector: this.injector};\n    }\n\n    /**\n     * Sets a descriptor instead of the default one.\n     *\n     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDescriptor(fn: TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>): this {\n        this._descriptor = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the descriptor using the provided adjust function.\n     *\n     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDescriptor(adjustFn: (descriptor: Descriptor) => void): this {\n        adjustFn(this._descriptor);\n        return this;\n    }\n\n    /**\n     * Sets the data provider for the TvBuilder instance\n     *\n     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * * @returns {this} - Returns the current instance of the builder.\n     */\n    withDataProvider(fn: TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>): this {\n        this._dataProvider = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider using the provided adjust function.\n     *\n     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDataProvider(adjustFn: (dataProvider: DataProvider) => void): this {\n        adjustFn(this._dataProvider);\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider and/or descriptor using the provided adjust function.\n     *\n     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjust(adjustFn: (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void): this {\n        adjustFn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Associates a fetch function for a data provider API service with the specified parameters.\n     *\n     * @param {ServiceFn} serviceFn The function from the service class that performs the fetch API call.\n     *                              Must be a key of the service with a parameter and return an Observable.\n     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of fetch function on API service.\n     */\n    withDataServiceFetchFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<Model>>>(\n        serviceFn: ServiceFn,\n        itemIdParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>\n    ): this {\n        if (this._dataProvider instanceof TableviewDataProviderInst) {\n            this._dataProvider.withFetch((itemId, service) => service[serviceFn]({[itemIdParamName]: itemId}));\n        }\n        return this;\n    }\n\n    /**\n     * Associates a create function for a data provider API service with the specified parameters.\n     *\n     * @param {ServiceFn} serviceFn The function from the service class that performs the create API call.\n     *                              Must be a key of the service with a parameter and return an Observable.\n     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} serviceFnItemParamName The parameter name for item used as the key within the request object of create function on API service.\n     * @param {EditorDataProviderFetchMapToFnType<Model, AddModel>} [mapFetchItem] Map function to transform model from fetch to form's add model.\n     */\n    withDataServiceCreateFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<any>>>(\n        serviceFn: ServiceFn,\n        serviceFnItemParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, AddModel>,\n        mapFetchItem?: EditorDataProviderFetchMapToFnType<Model, AddModel>\n    ): this {\n        if (this._dataProvider instanceof TableviewDataProviderInst) {\n            this._dataProvider.withCreate((item, service) => service[serviceFn]({[serviceFnItemParamName]: item}));\n\n            if (mapFetchItem) {\n                this._dataProvider.withMapFetchItemToCreateItem(mapFetchItem);\n            }\n        }\n        return this;\n    }\n\n    /**\n     * Associates an update function for a data provider API service with the specified parameters.\n     *\n     * @param {ServiceFn} serviceFn The function from the service class that performs the update API call.\n     *                              Must be a key of the service with a parameter and return an Observable.\n     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, Undefined<EditModel>>} fnItemParamName The parameter name for item used as the key within the request object of update function on API service.\n     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} [fnItemIdParamName] The parameter name for itemId used as the key within the request object of update function on API service.\n     * @param {EditorDataProviderFetchMapToFnType<Model, EditModel>} [mapFetchItem] Map function to transform model from fetch to form' edit model.\n     */\n    withDataServiceUpdateFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<any>>>(\n        serviceFn: ServiceFn,\n        fnItemParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, EditModel>,\n        fnItemIdParamName?: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>,\n        mapFetchItem?: EditorDataProviderFetchMapToFnType<Model, EditModel>\n    ): this {\n        if (this._dataProvider instanceof TableviewDataProviderInst) {\n            this._dataProvider.withUpdate((id, item, service) => {\n                const params: any = {[fnItemParamName]: item};\n                if (fnItemIdParamName) {\n                    params[fnItemIdParamName] = id;\n                }\n                return service[serviceFn](params);\n            });\n\n            if (mapFetchItem) {\n                this._dataProvider.withMapFetchItemToUpdateItem(mapFetchItem);\n            }\n        }\n        return this;\n    }\n\n    /**\n     * Associates a delete function for a data provider API service with the specified parameters.\n     *\n     * @param {ServiceFn} serviceFn The function from the service class that performs the delete API call.\n     *                              Must be a key of the service with a parameter and return an Observable.\n     * @param {ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>} fnItemIdParamName The parameter name for itemId used as the key within the request object of delete function on API service.\n     */\n    withDataServiceDeleteFn<ServiceFn extends ClassFunctionKeysWithParamAndReturnType<Service, any, Observable<any>>>(\n        serviceFn: ServiceFn,\n        fnItemIdParamName: ClassFunctionKeyParam1ObjKeyExtendsOfTargetType<Service, ServiceFn, IdType>\n    ): this {\n        if (this._dataProvider instanceof TableviewDataProviderInst) {\n            this._dataProvider.withDelete((itemId, service) => service[serviceFn]({[fnItemIdParamName]: itemId}));\n        }\n        return this;\n    }\n\n    /**\n     * Removes all the default tableview actions.\n     *\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withNoDefaultActions(): this {\n        this.defaultActions.forEach(a => (a.descriptor = null));\n        return this;\n    }\n\n    /**\n     * Adds the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action?.descriptor === null) {\n                action.descriptor = undefined;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Removes the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withoutDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action) {\n                action.descriptor = null;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Overrides the default action.\n     *\n     * @param {TableviewDefaultActionsEnum} type - The default actions to override.\n     * @param {TvBuilderActionSetterFnType<Model, ActionService , ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActionOverride<ActionService = Service, ActionRunInput = Model, ActionRunResult = Model, ValidationInput = Model>(\n        type: TableviewDefaultActionsEnum,\n        fn: TvBuilderActionSetterFnType<Model, ActionService, ActionRunInput, ActionRunResult, ValidationInput, Descriptor, DataProvider>\n    ): this {\n        const action = this.defaultActions.find(a => a.type === type);\n        if (action) {\n            action.descriptor = fn(this.prepareSetterParams()) ?? null;\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action.\n     *\n     * @deprecated Use on of {withActionOnTable}, {withActionOnDetailsEditor}, {withActionOnEditEditor} or {withActionOnAddEditor} instead.\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunInput, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAction<ActionModel = Model, ActionService = Service, ActionRunInput = Model, ActionRunResult = Model, ValidationInput = Model>(\n        fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionRunInput, ActionRunResult, ValidationInput, Descriptor, DataProvider>\n    ): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action on table row or top (header or toolbar).\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withActionOnTable<ActionModel = Model, ActionService = Service, ActionInput extends TableModel | undefined = TableModel, ActionRunResult = Model>(\n        fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionRunResult, ActionInput, Descriptor, DataProvider>\n    ): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            action.withPositionTableviewCategories([TableviewActionDefaultCategories.READ]);\n            if (\n                ![\n                    ActionPositionEnum.ToolbarLeft,\n                    ActionPositionEnum.ToolbarRight,\n                    ActionPositionEnum.TableHeader,\n                    ActionPositionEnum.RowInline,\n                    ActionPositionEnum.RowClick\n                ].includes(action.position)\n            ) {\n                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on table (${action.position}), define valid position.`);\n            }\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action on details editor.\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withActionOnDetailsEditor<ActionModel = Model, ActionService = Service, ActionInput extends Model = Model, ActionResult = Model>(\n        fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ActionInput, Descriptor, DataProvider>\n    ): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            action.withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS]);\n            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {\n                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on details (${action.position}), define valid position.`);\n            }\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action on edit editor.\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withActionOnEditEditor<ActionModel = Model, ActionService = Service, ActionInput extends EditModel = EditModel, ActionResult = Model>(\n        fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ActionInput, Descriptor, DataProvider>\n    ): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            action.withPositionTableviewCategories([TableviewActionDefaultCategories.EDIT]);\n            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {\n                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on edit (${action.position}), define valid position.`);\n            }\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action on add editor.\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, ActionRunResult, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @param {ActionPositionEnum} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withActionOnAddEditor<ActionModel = Model, ActionService = Service, ActionInput extends AddModel = AddModel, ActionResult = Model>(\n        fn: TvBuilderActionSetterFnType<ActionModel, ActionService, ActionInput, ActionResult, ActionInput, Descriptor, DataProvider>\n    ): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            action.withPositionTableviewCategories([TableviewActionDefaultCategories.ADD]);\n            if (![ActionPositionEnum.ToolbarLeft, ActionPositionEnum.ToolbarRight, ActionPositionEnum.FooterLeft, ActionPositionEnum.FooterRight].includes(action.position)) {\n                throw new CommonsInternalError(`Action ${action.actionNameLong} can not be positioned on add (${action.position}), define valid position.`);\n            }\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * @internal\n     *\n     * Builds and returns an instance of ITableview.\n     * DO NOT CALL this within tableview create callback function!\n     *\n     * @return {TableviewInput<Model, Service, Sorts, Filters, TableModel, AddModel, EditModel, Descriptor, DataProvider>} - The built ITableview instance.\n     */\n    build() {\n        return <TableviewInput<Model, Service, Sorts, Filters, TableModel, AddModel, EditModel, Descriptor, DataProvider>>{\n            actions: tableviewCreateDefaultActions(\n                this._descriptor as TableviewDescriptorInst<any, any, any, any, any, any, any, any>,\n                this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type),\n                this.defaultActions\n                    .filter(a => a.descriptor != null)\n                    .reduce(\n                        (acc, a) => ({\n                            ...acc,\n                            [a.type]: a.descriptor!\n                        }),\n                        <Record<number, ActionDescriptorInst<any>>>{}\n                    ),\n                this.injector\n            ).concat(this._customActions),\n            dataProvider: this._dataProvider,\n            descriptor: this._descriptor\n        };\n    }\n}\n"]}

package/esm2022/tableview/api/tableview/models/tableview-descriptor-fields-manage-helper.type.mjs

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

package/esm2022/tableview/api/tableview/models/tableview-descriptor-helper.type.mjs

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

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

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

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGV2aWV3LXJvdXRlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vdGFibGV2aWV3L2FwaS9zcmMvdGFibGV2aWV3L21vZGVscy90YWJsZXZpZXctcm91dGUubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QVBlcm1pc3Npb25zLCBDb21tb25zUm91dGVEYXRhfSBmcm9tICdAbWVkaXVzaW5jL21uZy1jb21tb25zL2NvcmUnO1xuXG5pbXBvcnQge0FjdGlvbkRlc2NyaXB0b3JJbnN0fSBmcm9tICcuLi8uLi9hY3Rpb24vZGVzY3JpcHRvcnMvYWN0aW9uLmRlc2NyaXB0b3InO1xuaW1wb3J0IHtJVGFibGV2aWV3RGF0YVByb3ZpZGVyfSBmcm9tICcuLi9kYXRhLXByb3ZpZGVycy90YWJsZXZpZXcuZGF0YS1wcm92aWRlcic7XG5pbXBvcnQge1RhYmxldmlld0Rlc2NyaXB0b3JJbnN0fSBmcm9tICcuLi9kZXNjcmlwdG9ycy90YWJsZXZpZXcuZGVzY3JpcHRvcic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGFibGV2aWV3Um91dGVEYXRhIGV4dGVuZHMgQ29tbW9uc1JvdXRlRGF0YSB7XG4gICAgdGFibGV2aWV3Pzoge1xuICAgICAgICBkZXNjcmlwdG9yOiBUYWJsZXZpZXdEZXNjcmlwdG9ySW5zdDxhbnksIGFueSwgYW55PjtcbiAgICAgICAgZGF0YVByb3ZpZGVyOiBJVGFibGV2aWV3RGF0YVByb3ZpZGVyO1xuICAgICAgICBhY3Rpb25zPzogQXJyYXk8QWN0aW9uRGVzY3JpcHRvckluc3Q8YW55Pj47XG4gICAgfTtcbiAgICB0YWJsZXZpZXdQZXJtaXNzaW9ucz86IHtcbiAgICAgICAgW2tleTogc3RyaW5nXTogQVBlcm1pc3Npb25zO1xuICAgIH07XG4gICAgLy8gdGFibGV2aWV3IGFjdGlvbnMgZGVmaW5lZCB2aWEgcm91dGUgYnVpbGRlclxuICAgIHRhYmxldmlld0FjdGlvbnM/OiB7XG4gICAgICAgIGhhc0FkZD86IGJvb2xlYW47XG4gICAgICAgIGhhc0VkaXQ/OiBib29sZWFuO1xuICAgICAgICBoYXNEZXRhaWxzPzogYm9vbGVhbjtcbiAgICAgICAgaGFzRGVsZXRlPzogYm9vbGVhbjtcbiAgICB9O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGV2aWV3LXJvdXRlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vdGFibGV2aWV3L2FwaS9zcmMvdGFibGV2aWV3L21vZGVscy90YWJsZXZpZXctcm91dGUubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QVBlcm1pc3Npb25zLCBDb21tb25zUm91dGVEYXRhfSBmcm9tICdAbWVkaXVzaW5jL21uZy1jb21tb25zL2NvcmUnO1xuXG5pbXBvcnQge0FjdGlvbkRlc2NyaXB0b3JJbnN0fSBmcm9tICcuLi8uLi9hY3Rpb24vZGVzY3JpcHRvcnMvYWN0aW9uLmRlc2NyaXB0b3InO1xuaW1wb3J0IHtJVGFibGV2aWV3RGF0YVByb3ZpZGVyfSBmcm9tICcuLi9kYXRhLXByb3ZpZGVycy90YWJsZXZpZXcuZGF0YS1wcm92aWRlcic7XG5pbXBvcnQge1RhYmxldmlld0Rlc2NyaXB0b3JJbnN0fSBmcm9tICcuLi9kZXNjcmlwdG9ycy90YWJsZXZpZXcuZGVzY3JpcHRvcic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGFibGV2aWV3Um91dGVEYXRhIGV4dGVuZHMgQ29tbW9uc1JvdXRlRGF0YSB7XG4gICAgdGFibGV2aWV3Pzoge1xuICAgICAgICBkZXNjcmlwdG9yOiBUYWJsZXZpZXdEZXNjcmlwdG9ySW5zdDxhbnksIGFueSwgYW55LCBhbnk+O1xuICAgICAgICBkYXRhUHJvdmlkZXI6IElUYWJsZXZpZXdEYXRhUHJvdmlkZXI7XG4gICAgICAgIGFjdGlvbnM/OiBBcnJheTxBY3Rpb25EZXNjcmlwdG9ySW5zdDxhbnk+PjtcbiAgICB9O1xuICAgIHRhYmxldmlld1Blcm1pc3Npb25zPzoge1xuICAgICAgICBba2V5OiBzdHJpbmddOiBBUGVybWlzc2lvbnM7XG4gICAgfTtcbiAgICAvLyB0YWJsZXZpZXcgYWN0aW9ucyBkZWZpbmVkIHZpYSByb3V0ZSBidWlsZGVyXG4gICAgdGFibGV2aWV3QWN0aW9ucz86IHtcbiAgICAgICAgaGFzQWRkPzogYm9vbGVhbjtcbiAgICAgICAgaGFzRWRpdD86IGJvb2xlYW47XG4gICAgICAgIGhhc0RldGFpbHM/OiBib29sZWFuO1xuICAgICAgICBoYXNEZWxldGU/OiBib29sZWFuO1xuICAgIH07XG59XG4iXX0=

package/esm2022/tableview/editor/components/formly/fields/formly-field-table-dialog-form/formly-field-table-dialog-form.component.mjs

@@ -7,7 +7,7 @@ import { BehaviorSubject, distinctUntilChanged, of, throwError } from 'rxjs';
 import { map, startWith } from 'rxjs/operators';
 import { CommonsInternalError, CommonsService, StyleLevelEnum, StyleSizeEnum, TemplateDirective } from '@mediusinc/mng-commons/core';
 import { ActionButtonDescriptor, ButtonStyleBuilder } from '@mediusinc/mng-commons/form/api';
-import { ActionDescriptorInst, ActionEditorDescriptor, ActionPositionEnum, FieldManyEditorActionEnum, FormFieldEventComponentSubtype, FormFieldEventTypeEnum, actionEditorCancel } from '@mediusinc/mng-commons/tableview/api';
+import { ActionPositionEnum, FieldManyEditorActionEnum, FormFieldEventComponentSubtype, FormFieldEventTypeEnum, action, actionEditor, actionEditorCancel } from '@mediusinc/mng-commons/tableview/api';
 import { ActionComponent } from '../../../../../action/components/action/action.component';
 import { ActionTableComponent } from '../../../../../action/components/table/action-table.component';
 import { provideViewContainer } from '../../../../../action/services/providers/provide-view-container';
@@ -36,7 +36,7 @@ export class FormlyFieldTableDialogFormComponent extends ACommonsFormlyFieldType
         const hasEditAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Edit);
         const hasDeleteAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Delete);
         if (hasViewAction) {
-            const viewAction = ActionEditorDescriptor.create(this.descriptor.tableviewDescriptor.detailsEditor, 'details', {
+            const viewAction = actionEditor('details', this.descriptor.tableviewDescriptor.detailsEditor, {
                 parentModel: this.editorDescriptor.model,
                 parentProperty: this.descriptor.property
             })
@@ -51,7 +51,7 @@ export class FormlyFieldTableDialogFormComponent extends ACommonsFormlyFieldType
             this.actions.push(viewAction);
         }
         if (hasAddAction) {
-            const addAction = ActionEditorDescriptor.create(this.descriptor.tableviewDescriptor.addEditor, 'add', {
+            const addAction = actionEditor('add', this.descriptor.tableviewDescriptor.addEditor, {
                 parentModel: this.editorDescriptor.model,
                 parentProperty: this.descriptor.property
             })
@@ -82,7 +82,7 @@ export class FormlyFieldTableDialogFormComponent extends ACommonsFormlyFieldType
             this.actions.push(addAction);
         }
         if (hasEditAction) {
-            const editAction = ActionEditorDescriptor.create(this.descriptor.tableviewDescriptor.editEditor, 'edit', {
+            const editAction = actionEditor('edit', this.descriptor.tableviewDescriptor.editEditor, {
                 parentModel: this.editorDescriptor.model,
                 parentProperty: this.descriptor.property
             })
@@ -113,7 +113,7 @@ export class FormlyFieldTableDialogFormComponent extends ACommonsFormlyFieldType
             this.actions.push(editAction);
         }
         if (hasDeleteAction) {
-            const deleteAction = new ActionDescriptorInst('delete', {
+            const deleteAction = action('delete', {
                 model: this.descriptor.tableviewDescriptor.model,
                 parentModel: this.editorDescriptor.model,
                 parentProperty: this.descriptor.property
@@ -225,4 +225,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.12", ngImpo
             type: Component,
             args: [{ standalone: true, selector: 'mng-formly-table-dialog-form-field', imports: [TranslateModule, ActionComponent, ActionTableComponent, TemplateDirective, FormlyFieldLabelPipe, TooltipModule, NgClass], providers: [provideViewContainer(false)], changeDetection: ChangeDetectionStrategy.OnPush, template: "<mng-action-table [descriptor]=\"descriptor.tableDescriptor\" [items]=\"items()\" [actions]=\"actions\" [rowReorderEnabled]=\"!disableRowReorder()\" (rowReorder)=\"onRowReorder($event)\">\n    <ng-template mngTemplate=\"caption\">\n        <div class=\"flex justify-content-end align-items-center\">\n            <label class=\"mng-datatable-form-label p-0 m-0\" [for]=\"key\"\n                >{{ descriptor | mngFormlyFieldLabel: editorDescriptor | translate }}\n                @if (props.required && props['hideRequiredMarker'] !== true) {\n                    <span>*</span>\n                }\n                @if (descriptor.labelInfoTooltip !== undefined) {\n                    <span [ngClass]=\"{'ml-1': props.required && props['hideRequiredMarker'] !== true}\">\n                        <i [class]=\"descriptor.labelInfoTooltipIcon ?? labelInfoTooltipDefaultIcon\" [pTooltip]=\"descriptor.labelInfoTooltip | translate\"></i>\n                    </span>\n                }\n            </label>\n            <div>\n                @for (action of toolbarRightActions; track action) {\n                    <mng-action [action]=\"action\"></mng-action>\n                }\n            </div>\n        </div>\n    </ng-template>\n</mng-action-table>\n", styles: [".submit-button{display:none!important;visibility:hidden}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly-field-table-dialog-form.component.js","sourceRoot":"","sources":["../../../../../../../../tableview/src/editor/components/formly/fields/formly-field-table-dialog-form/formly-field-table-dialog-form.component.ts","../../../../../../../../tableview/src/editor/components/formly/fields/formly-field-table-dialog-form/formly-field-table-dialog-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {NgClass} from '@angular/common';\nimport {AfterViewInit, ChangeDetectionStrategy, Component, Injector, OnDestroy, OnInit, inject, signal} from '@angular/core';\nimport {takeUntilDestroyed, toSignal} from '@angular/core/rxjs-interop';\n\nimport {TranslateModule} from '@ngx-translate/core';\nimport {TableRowReorderEvent} from 'primeng/table';\nimport {TooltipModule} from 'primeng/tooltip';\nimport {BehaviorSubject, distinctUntilChanged, of, throwError} from 'rxjs';\nimport {map, startWith} from 'rxjs/operators';\n\nimport {CommonsInternalError, CommonsService, StyleLevelEnum, StyleSizeEnum, TemplateDirective} from '@mediusinc/mng-commons/core';\nimport {ActionButtonDescriptor, ButtonStyleBuilder} from '@mediusinc/mng-commons/form/api';\nimport {\n    ActionContextValidation,\n    ActionDescriptorInst,\n    ActionEditorDescriptor,\n    ActionPositionEnum,\n    FieldManyEditorActionEnum,\n    FieldManyEditorDescriptor,\n    FormFieldEventComponentSubtype,\n    FormFieldEventTypeEnum,\n    actionEditorCancel\n} from '@mediusinc/mng-commons/tableview/api';\n\nimport {ActionComponent} from '../../../../../action/components/action/action.component';\nimport {ActionTableComponent} from '../../../../../action/components/table/action-table.component';\nimport {provideViewContainer} from '../../../../../action/services/providers/provide-view-container';\nimport {labelInfoTooltipDefaultIcon} from '../../constants';\nimport {FormlyFieldLabelPipe} from '../../pipes/formly-field-label.pipe';\nimport {ACommonsFormlyFieldType} from '../formly-field-type.abstract.component';\n\n@Component({\n    standalone: true,\n    selector: 'mng-formly-table-dialog-form-field',\n    templateUrl: './formly-field-table-dialog-form.component.html',\n    styleUrls: ['./formly-field-table-dialog-form.component.scss'],\n    imports: [TranslateModule, ActionComponent, ActionTableComponent, TemplateDirective, FormlyFieldLabelPipe, TooltipModule, NgClass],\n    providers: [provideViewContainer(false)],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FormlyFieldTableDialogFormComponent<T = any, ET = any>\n    extends ACommonsFormlyFieldType<T[], ET, FieldManyEditorDescriptor<T, ET>>\n    implements OnInit, AfterViewInit, OnDestroy\n{\n    private readonly injector = inject(Injector);\n    protected readonly labelInfoTooltipDefaultIcon = labelInfoTooltipDefaultIcon;\n\n    public items = signal<T[]>([]);\n\n    public actions: Array<ActionDescriptorInst<T>> = [];\n    public toolbarRightActions: Array<ActionDescriptorInst<T>> = [];\n\n    private isDisabledSubject = new BehaviorSubject<boolean>(false);\n    private isEnabled$ = this.isDisabledSubject.asObservable().pipe(\n        distinctUntilChanged(),\n        map(e => !e)\n    );\n\n    public disableRowReorder = toSignal<boolean>(this.formStateDisabled$);\n\n    public override ngOnInit() {\n        super.ngOnInit();\n\n        const hasViewAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.View);\n        const hasAddAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Add);\n        const hasEditAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Edit);\n        const hasDeleteAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Delete);\n\n        if (hasViewAction) {\n            const viewAction = ActionEditorDescriptor.create(this.descriptor.tableviewDescriptor.detailsEditor, 'details', {\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.RowClick)\n                .withDialogSize(StyleSizeEnum.Small)\n                .withFetchFunction(ctx => {\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item || ({} as T));\n                });\n            viewAction.withEditorActions([actionEditorCancel(viewAction)]);\n            viewAction.button.withLabel(null);\n            this.actions.push(viewAction);\n        }\n\n        if (hasAddAction) {\n            const addAction = ActionEditorDescriptor.create(this.descriptor.tableviewDescriptor.addEditor, 'add', {\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.ToolbarRight)\n                .withDialogSize(StyleSizeEnum.Small)\n                .withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withSize(StyleSizeEnum.ExtraSmall)))\n                .withFetchFunction(ctx => {\n                    setTimeout(this.formControl.markAsTouched, 0);\n                    return of(ctx.parameters.item || ({} as T));\n                })\n                .withSubmitFunction(ctx => {\n                    if (!ctx.parameters.item) {\n                        return throwError(\n                            () => new CommonsInternalError(`No item was provided in context, add cannot be done.`, {name: 'FormlyFieldTableDialogFormComponentError'})\n                        );\n                    }\n                    this.formState.submittedOn = Date.now();\n                    let value = this.formControl.value;\n                    value = [...value, ctx.parameters.item];\n                    this.formControl.patchValue(value);\n                    this.formControl.markAsDirty();\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item);\n                })\n                .withRunNotificationSuccess(undefined, undefined, false)\n                .withRunNotificationError(undefined, undefined, false)\n                .withIsVisibleFunction(() => this.formStateDisabled$.pipe(map(v => !v)))\n                .withIsEnabledFunction(() => this.isEnabled$);\n            addAction.button.withLabel(null).withIcon('pi pi-plus');\n            this.actions.push(addAction);\n        }\n        if (hasEditAction) {\n            const editAction = ActionEditorDescriptor.create(this.descriptor.tableviewDescriptor.editEditor, 'edit', {\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.RowInline)\n                .withDialogSize(StyleSizeEnum.Small)\n                .withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withSize(StyleSizeEnum.ExtraSmall)))\n                .withFetchFunction(ctx => {\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item || ({} as T));\n                })\n                .withSubmitFunction(ctx => {\n                    if (!ctx.parameters.item) {\n                        return throwError(\n                            () => new CommonsInternalError(`No item was provided in context, edit cannot be done.`, {name: 'FormlyFieldTableDialogFormComponentError'})\n                        );\n                    }\n                    this.formState.submittedOn = Date.now();\n                    const formControlValue = [...this.formControl.value];\n                    formControlValue[ctx.parameters.actionData?.['itemIndex']] = ctx.parameters.item;\n                    this.formControl.patchValue(formControlValue);\n                    this.formControl.markAsDirty();\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item);\n                })\n                .withRunNotificationSuccess(undefined, undefined, false)\n                .withRunNotificationError(undefined, undefined, false)\n                .withIsVisibleFunction(ctx => (this.hideActionsForRowWithDefaultLocalization(ctx) ? of(false) : this.formStateDisabled$.pipe(map(v => !v))))\n                .withIsEnabledFunction(() => this.isEnabled$);\n            editAction.button.withLabel(null).withIcon('pi pi-pencil');\n            this.actions.push(editAction);\n        }\n        if (hasDeleteAction) {\n            const deleteAction = new ActionDescriptorInst('delete', {\n                model: this.descriptor.tableviewDescriptor.model,\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.RowInline)\n                .withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder(StyleLevelEnum.Danger).withSize(StyleSizeEnum.ExtraSmall)))\n                .withRunFunction(ctx => {\n                    if (!ctx.parameters.item) {\n                        return throwError(\n                            () => new CommonsInternalError(`No item was provided in context, delete cannot be done.`, {name: 'FormlyFieldTableDialogFormComponentError'})\n                        );\n                    }\n                    let formControlValue = this.formControl.value;\n                    const compareProperty = this.descriptor.tableDescriptor.trackProperty\n                        ? this.descriptor.tableDescriptor.trackProperty\n                        : this.descriptor.tableDescriptor.model.idProperty;\n                    const ctxItem: any = ctx.parameters.item;\n                    if (compareProperty && ctxItem?.[compareProperty]) {\n                        formControlValue = formControlValue.filter((i: any) => i[compareProperty] !== ctxItem[compareProperty]);\n                        this.formControl.patchValue(formControlValue);\n                        this.formControl.markAsDirty();\n                    } else if (typeof ctx.parameters.actionData?.['itemIndex'] === 'number') {\n                        formControlValue.splice(ctx.parameters.actionData['itemIndex'], 1);\n                        this.formControl.patchValue([...formControlValue]);\n                        this.formControl.markAsDirty();\n                    } else {\n                        return throwError(\n                            () =>\n                                new CommonsInternalError('Cannot compare items, please provide main table data key property or model id property.', {\n                                    name: 'FormlyFieldTableDialogFormComponentError'\n                                })\n                        );\n                    }\n\n                    this.formControl.markAsTouched();\n\n                    return of(ctxItem);\n                })\n                .withRunNotificationSuccess(undefined, undefined, false)\n                .withRunNotificationError(undefined, undefined, false)\n                .withIsVisibleFunction(ctx => (this.hideActionsForRowWithDefaultLocalization(ctx) ? of(false) : this.formStateDisabled$.pipe(map(v => !v))))\n                .withIsEnabledFunction(() => this.isEnabled$);\n            deleteAction.button.withLabel(null).withIcon('pi pi-trash');\n            this.actions.push(deleteAction);\n        }\n\n        this.actions.push(...this.descriptor.actions);\n        for (const action of this.actions) {\n            switch (action.position) {\n                case ActionPositionEnum.ToolbarRight:\n                    this.toolbarRightActions.push(action);\n                    break;\n            }\n        }\n\n        // init values\n        if (typeof this.formControl.value === 'undefined' || this.formControl.value === null) {\n            this.formControl.patchValue([]);\n        }\n\n        // emit lifecycle event\n        this.descriptor.nextEvent(FormFieldEventTypeEnum.ComponentLifecycle, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_INIT\n        });\n\n        this.formControl.valueChanges.pipe(startWith(this.formControl.value), takeUntilDestroyed(this.destroyRef)).subscribe(v => {\n            this.items.set(v ?? []);\n\n            // emit lifecycle event\n            this.descriptor.nextEvent(FormFieldEventTypeEnum.ValueChange, this, {\n                value: v\n            });\n\n            this.props.onValueChange?.(this.field, v);\n        });\n\n        this.isDisabledSubject.next(this.formControl.disabled);\n        this.formControl.statusChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(status => {\n            if (status === 'DISABLED' && !this.isDisabledSubject.value) {\n                this.isDisabledSubject.next(true);\n            } else if (status !== 'DISABLED' && this.isDisabledSubject.value) {\n                this.isDisabledSubject.next(false);\n            }\n        });\n    }\n\n    public onRowReorder(event: TableRowReorderEvent): void {\n        if (event.dragIndex === undefined || event.dropIndex === undefined) return;\n        // update formControl\n        const newValue = [...this.formControl.value];\n        const draggedItem = newValue[event.dragIndex];\n        newValue.splice(event.dragIndex, 1);\n        newValue.splice(event.dropIndex, 0, draggedItem);\n        this.formControl.setValue(newValue);\n\n        this.descriptor.nextEvent(FormFieldEventTypeEnum.RowReorder, this, {dragIndex: event.dragIndex, dropIndex: event.dropIndex});\n    }\n\n    public ngAfterViewInit() {\n        this.descriptor.nextEvent(FormFieldEventTypeEnum.ComponentLifecycle, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_VIEW_INIT\n        });\n    }\n\n    public ngOnDestroy() {\n        // emit lifecycle event\n        this.descriptor?.nextEvent(FormFieldEventTypeEnum.ComponentLifecycle, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_DESTROY\n        });\n    }\n\n    private hideActionsForRowWithDefaultLocalization(ctx: ActionContextValidation<T>) {\n        if (this.descriptor.tableDescriptor.isLocalized) {\n            if (ctx.parameters.item?.[this.descriptor.tableDescriptor.localizationLocaleProperty! as keyof object] === this.injector.get(CommonsService).getDefaultLocale()) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n","<mng-action-table [descriptor]=\"descriptor.tableDescriptor\" [items]=\"items()\" [actions]=\"actions\" [rowReorderEnabled]=\"!disableRowReorder()\" (rowReorder)=\"onRowReorder($event)\">\n    <ng-template mngTemplate=\"caption\">\n        <div class=\"flex justify-content-end align-items-center\">\n            <label class=\"mng-datatable-form-label p-0 m-0\" [for]=\"key\"\n                >{{ descriptor | mngFormlyFieldLabel: editorDescriptor | translate }}\n                @if (props.required && props['hideRequiredMarker'] !== true) {\n                    <span>*</span>\n                }\n                @if (descriptor.labelInfoTooltip !== undefined) {\n                    <span [ngClass]=\"{'ml-1': props.required && props['hideRequiredMarker'] !== true}\">\n                        <i [class]=\"descriptor.labelInfoTooltipIcon ?? labelInfoTooltipDefaultIcon\" [pTooltip]=\"descriptor.labelInfoTooltip | translate\"></i>\n                    </span>\n                }\n            </label>\n            <div>\n                @for (action of toolbarRightActions; track action) {\n                    <mng-action [action]=\"action\"></mng-action>\n                }\n            </div>\n        </div>\n    </ng-template>\n</mng-action-table>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly-field-table-dialog-form.component.js","sourceRoot":"","sources":["../../../../../../../../tableview/src/editor/components/formly/fields/formly-field-table-dialog-form/formly-field-table-dialog-form.component.ts","../../../../../../../../tableview/src/editor/components/formly/fields/formly-field-table-dialog-form/formly-field-table-dialog-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {NgClass} from '@angular/common';\nimport {AfterViewInit, ChangeDetectionStrategy, Component, Injector, OnDestroy, OnInit, inject, signal} from '@angular/core';\nimport {takeUntilDestroyed, toSignal} from '@angular/core/rxjs-interop';\n\nimport {TranslateModule} from '@ngx-translate/core';\nimport {TableRowReorderEvent} from 'primeng/table';\nimport {TooltipModule} from 'primeng/tooltip';\nimport {BehaviorSubject, distinctUntilChanged, of, throwError} from 'rxjs';\nimport {map, startWith} from 'rxjs/operators';\n\nimport {CommonsInternalError, CommonsService, StyleLevelEnum, StyleSizeEnum, TemplateDirective} from '@mediusinc/mng-commons/core';\nimport {ActionButtonDescriptor, ButtonStyleBuilder} from '@mediusinc/mng-commons/form/api';\nimport {\n    ActionContextValidation,\n    ActionDescriptorInst,\n    ActionPositionEnum,\n    FieldManyEditorActionEnum,\n    FieldManyEditorDescriptor,\n    FormFieldEventComponentSubtype,\n    FormFieldEventTypeEnum,\n    action,\n    actionEditor,\n    actionEditorCancel\n} from '@mediusinc/mng-commons/tableview/api';\n\nimport {ActionComponent} from '../../../../../action/components/action/action.component';\nimport {ActionTableComponent} from '../../../../../action/components/table/action-table.component';\nimport {provideViewContainer} from '../../../../../action/services/providers/provide-view-container';\nimport {labelInfoTooltipDefaultIcon} from '../../constants';\nimport {FormlyFieldLabelPipe} from '../../pipes/formly-field-label.pipe';\nimport {ACommonsFormlyFieldType} from '../formly-field-type.abstract.component';\n\n@Component({\n    standalone: true,\n    selector: 'mng-formly-table-dialog-form-field',\n    templateUrl: './formly-field-table-dialog-form.component.html',\n    styleUrls: ['./formly-field-table-dialog-form.component.scss'],\n    imports: [TranslateModule, ActionComponent, ActionTableComponent, TemplateDirective, FormlyFieldLabelPipe, TooltipModule, NgClass],\n    providers: [provideViewContainer(false)],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FormlyFieldTableDialogFormComponent<T = any, ET = any>\n    extends ACommonsFormlyFieldType<T[], ET, FieldManyEditorDescriptor<T, ET>>\n    implements OnInit, AfterViewInit, OnDestroy\n{\n    private readonly injector = inject(Injector);\n    protected readonly labelInfoTooltipDefaultIcon = labelInfoTooltipDefaultIcon;\n\n    public items = signal<T[]>([]);\n\n    public actions: Array<ActionDescriptorInst<T>> = [];\n    public toolbarRightActions: Array<ActionDescriptorInst<T>> = [];\n\n    private isDisabledSubject = new BehaviorSubject<boolean>(false);\n    private isEnabled$ = this.isDisabledSubject.asObservable().pipe(\n        distinctUntilChanged(),\n        map(e => !e)\n    );\n\n    public disableRowReorder = toSignal<boolean>(this.formStateDisabled$);\n\n    public override ngOnInit() {\n        super.ngOnInit();\n\n        const hasViewAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.View);\n        const hasAddAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Add);\n        const hasEditAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Edit);\n        const hasDeleteAction = this.descriptor.fieldActions.some(a => a === FieldManyEditorActionEnum.Delete);\n\n        if (hasViewAction) {\n            const viewAction = actionEditor('details', this.descriptor.tableviewDescriptor.detailsEditor, {\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.RowClick)\n                .withDialogSize(StyleSizeEnum.Small)\n                .withFetchFunction(ctx => {\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item || ({} as T));\n                });\n            viewAction.withEditorActions([actionEditorCancel(viewAction)]);\n            viewAction.button.withLabel(null);\n            this.actions.push(viewAction);\n        }\n\n        if (hasAddAction) {\n            const addAction = actionEditor('add', this.descriptor.tableviewDescriptor.addEditor, {\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.ToolbarRight)\n                .withDialogSize(StyleSizeEnum.Small)\n                .withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withSize(StyleSizeEnum.ExtraSmall)))\n                .withFetchFunction(ctx => {\n                    setTimeout(this.formControl.markAsTouched, 0);\n                    return of(ctx.parameters.item || ({} as T));\n                })\n                .withSubmitFunction(ctx => {\n                    if (!ctx.parameters.item) {\n                        return throwError(\n                            () => new CommonsInternalError(`No item was provided in context, add cannot be done.`, {name: 'FormlyFieldTableDialogFormComponentError'})\n                        );\n                    }\n                    this.formState.submittedOn = Date.now();\n                    let value = this.formControl.value;\n                    value = [...value, ctx.parameters.item];\n                    this.formControl.patchValue(value);\n                    this.formControl.markAsDirty();\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item);\n                })\n                .withRunNotificationSuccess(undefined, undefined, false)\n                .withRunNotificationError(undefined, undefined, false)\n                .withIsVisibleFunction(() => this.formStateDisabled$.pipe(map(v => !v)))\n                .withIsEnabledFunction(() => this.isEnabled$);\n            addAction.button.withLabel(null).withIcon('pi pi-plus');\n            this.actions.push(addAction);\n        }\n        if (hasEditAction) {\n            const editAction = actionEditor('edit', this.descriptor.tableviewDescriptor.editEditor, {\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.RowInline)\n                .withDialogSize(StyleSizeEnum.Small)\n                .withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withSize(StyleSizeEnum.ExtraSmall)))\n                .withFetchFunction(ctx => {\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item || ({} as T));\n                })\n                .withSubmitFunction(ctx => {\n                    if (!ctx.parameters.item) {\n                        return throwError(\n                            () => new CommonsInternalError(`No item was provided in context, edit cannot be done.`, {name: 'FormlyFieldTableDialogFormComponentError'})\n                        );\n                    }\n                    this.formState.submittedOn = Date.now();\n                    const formControlValue = [...this.formControl.value];\n                    formControlValue[ctx.parameters.actionData?.['itemIndex']] = ctx.parameters.item;\n                    this.formControl.patchValue(formControlValue);\n                    this.formControl.markAsDirty();\n                    this.formControl.markAsTouched();\n                    return of(ctx.parameters.item);\n                })\n                .withRunNotificationSuccess(undefined, undefined, false)\n                .withRunNotificationError(undefined, undefined, false)\n                .withIsVisibleFunction(ctx => (this.hideActionsForRowWithDefaultLocalization(ctx) ? of(false) : this.formStateDisabled$.pipe(map(v => !v))))\n                .withIsEnabledFunction(() => this.isEnabled$);\n            editAction.button.withLabel(null).withIcon('pi pi-pencil');\n            this.actions.push(editAction);\n        }\n        if (hasDeleteAction) {\n            const deleteAction = action('delete', {\n                model: this.descriptor.tableviewDescriptor.model,\n                parentModel: this.editorDescriptor.model,\n                parentProperty: this.descriptor.property\n            })\n                .withPosition(ActionPositionEnum.RowInline)\n                .withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder(StyleLevelEnum.Danger).withSize(StyleSizeEnum.ExtraSmall)))\n                .withRunFunction(ctx => {\n                    if (!ctx.parameters.item) {\n                        return throwError(\n                            () => new CommonsInternalError(`No item was provided in context, delete cannot be done.`, {name: 'FormlyFieldTableDialogFormComponentError'})\n                        );\n                    }\n                    let formControlValue = this.formControl.value;\n                    const compareProperty = this.descriptor.tableDescriptor.trackProperty\n                        ? this.descriptor.tableDescriptor.trackProperty\n                        : this.descriptor.tableDescriptor.model.idProperty;\n                    const ctxItem: any = ctx.parameters.item;\n                    if (compareProperty && ctxItem?.[compareProperty]) {\n                        formControlValue = formControlValue.filter((i: any) => i[compareProperty] !== ctxItem[compareProperty]);\n                        this.formControl.patchValue(formControlValue);\n                        this.formControl.markAsDirty();\n                    } else if (typeof ctx.parameters.actionData?.['itemIndex'] === 'number') {\n                        formControlValue.splice(ctx.parameters.actionData['itemIndex'], 1);\n                        this.formControl.patchValue([...formControlValue]);\n                        this.formControl.markAsDirty();\n                    } else {\n                        return throwError(\n                            () =>\n                                new CommonsInternalError('Cannot compare items, please provide main table data key property or model id property.', {\n                                    name: 'FormlyFieldTableDialogFormComponentError'\n                                })\n                        );\n                    }\n\n                    this.formControl.markAsTouched();\n\n                    return of(ctxItem);\n                })\n                .withRunNotificationSuccess(undefined, undefined, false)\n                .withRunNotificationError(undefined, undefined, false)\n                .withIsVisibleFunction(ctx => (this.hideActionsForRowWithDefaultLocalization(ctx) ? of(false) : this.formStateDisabled$.pipe(map(v => !v))))\n                .withIsEnabledFunction(() => this.isEnabled$);\n            deleteAction.button.withLabel(null).withIcon('pi pi-trash');\n            this.actions.push(deleteAction);\n        }\n\n        this.actions.push(...this.descriptor.actions);\n        for (const action of this.actions) {\n            switch (action.position) {\n                case ActionPositionEnum.ToolbarRight:\n                    this.toolbarRightActions.push(action);\n                    break;\n            }\n        }\n\n        // init values\n        if (typeof this.formControl.value === 'undefined' || this.formControl.value === null) {\n            this.formControl.patchValue([]);\n        }\n\n        // emit lifecycle event\n        this.descriptor.nextEvent(FormFieldEventTypeEnum.ComponentLifecycle, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_INIT\n        });\n\n        this.formControl.valueChanges.pipe(startWith(this.formControl.value), takeUntilDestroyed(this.destroyRef)).subscribe(v => {\n            this.items.set(v ?? []);\n\n            // emit lifecycle event\n            this.descriptor.nextEvent(FormFieldEventTypeEnum.ValueChange, this, {\n                value: v\n            });\n\n            this.props.onValueChange?.(this.field, v);\n        });\n\n        this.isDisabledSubject.next(this.formControl.disabled);\n        this.formControl.statusChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(status => {\n            if (status === 'DISABLED' && !this.isDisabledSubject.value) {\n                this.isDisabledSubject.next(true);\n            } else if (status !== 'DISABLED' && this.isDisabledSubject.value) {\n                this.isDisabledSubject.next(false);\n            }\n        });\n    }\n\n    public onRowReorder(event: TableRowReorderEvent): void {\n        if (event.dragIndex === undefined || event.dropIndex === undefined) return;\n        // update formControl\n        const newValue = [...this.formControl.value];\n        const draggedItem = newValue[event.dragIndex];\n        newValue.splice(event.dragIndex, 1);\n        newValue.splice(event.dropIndex, 0, draggedItem);\n        this.formControl.setValue(newValue);\n\n        this.descriptor.nextEvent(FormFieldEventTypeEnum.RowReorder, this, {dragIndex: event.dragIndex, dropIndex: event.dropIndex});\n    }\n\n    public ngAfterViewInit() {\n        this.descriptor.nextEvent(FormFieldEventTypeEnum.ComponentLifecycle, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_VIEW_INIT\n        });\n    }\n\n    public ngOnDestroy() {\n        // emit lifecycle event\n        this.descriptor?.nextEvent(FormFieldEventTypeEnum.ComponentLifecycle, this, {\n            eventSubtype: FormFieldEventComponentSubtype.ON_DESTROY\n        });\n    }\n\n    private hideActionsForRowWithDefaultLocalization(ctx: ActionContextValidation<T, T>) {\n        if (this.descriptor.tableDescriptor.isLocalized) {\n            if (ctx.parameters.item?.[this.descriptor.tableDescriptor.localizationLocaleProperty! as keyof object] === this.injector.get(CommonsService).getDefaultLocale()) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n","<mng-action-table [descriptor]=\"descriptor.tableDescriptor\" [items]=\"items()\" [actions]=\"actions\" [rowReorderEnabled]=\"!disableRowReorder()\" (rowReorder)=\"onRowReorder($event)\">\n    <ng-template mngTemplate=\"caption\">\n        <div class=\"flex justify-content-end align-items-center\">\n            <label class=\"mng-datatable-form-label p-0 m-0\" [for]=\"key\"\n                >{{ descriptor | mngFormlyFieldLabel: editorDescriptor | translate }}\n                @if (props.required && props['hideRequiredMarker'] !== true) {\n                    <span>*</span>\n                }\n                @if (descriptor.labelInfoTooltip !== undefined) {\n                    <span [ngClass]=\"{'ml-1': props.required && props['hideRequiredMarker'] !== true}\">\n                        <i [class]=\"descriptor.labelInfoTooltipIcon ?? labelInfoTooltipDefaultIcon\" [pTooltip]=\"descriptor.labelInfoTooltip | translate\"></i>\n                    </span>\n                }\n            </label>\n            <div>\n                @for (action of toolbarRightActions; track action) {\n                    <mng-action [action]=\"action\"></mng-action>\n                }\n            </div>\n        </div>\n    </ng-template>\n</mng-action-table>\n"]}