@mediusinc/mng-commons 5.0.0-rc.2 → 5.0.0-rc.3

package/esm2022/tableview/action/services/view-container.service.mjs

@@ -1,4 +1,4 @@
-import { Injectable } from '@angular/core';
+import { Injectable, signal } from '@angular/core';
 import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 /**
@@ -6,23 +6,13 @@ import * as i0 from "@angular/core";
  */
 export class ViewContainer {
     constructor() {
-        this._actions = [];
+        this.dataProvider = signal(undefined);
+        this.routeTriggeredActionInstance = signal(undefined);
+        this.actions = signal([]);
         this._tableReloadSubject = new Subject();
         this._editorResetSubject = new Subject();
         this._editorCloseSubject = new Subject();
     }
-    set dataProvider(dataProvider) {
-        this._dataProvider = dataProvider;
-    }
-    get dataProvider() {
-        return this._dataProvider;
-    }
-    get actions() {
-        return this._actions;
-    }
-    set actions(actions) {
-        this._actions = actions;
-    }
     get tableReload$() {
         return this._tableReloadSubject.asObservable();
     }
@@ -41,16 +31,10 @@ export class ViewContainer {
     closeEditor(event) {
         this._editorCloseSubject.next(event ?? {});
     }
-    get routeTriggeredActionInstance() {
-        return this._routeTriggeredActionInstance;
-    }
-    set routeTriggeredActionInstance(instance) {
-        this._routeTriggeredActionInstance = instance;
-    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ViewContainer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ViewContainer }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: ViewContainer, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,119 @@
+import { ModelDescriptor, TypeDescriptor } from '@mediusinc/mng-commons/model';
+import { ActionDeleteDescriptorInst, ActionDescriptorInst } from './action.descriptor';
+export const actionGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+export class ActionDescriptor extends ActionDescriptorInst {
+    constructor() {
+        super('internal');
+    }
+    static create(actionName, cfg) {
+        return action(actionName, {
+            ...cfg
+        });
+    }
+    static createWithProvider(serviceProvider, actionName, cfg) {
+        return actionWithProvider(serviceProvider, actionName, cfg);
+    }
+    static fromModel(model, actionName, cfg) {
+        return actionFromModel(model, actionName, cfg);
+    }
+    static fromModelWithProvider(model, serviceProvider, actionName, cfg) {
+        return actionFromModel(model, serviceProvider, actionName, cfg);
+    }
+    static fromClass(type, actionName, cfg) {
+        return actionFromClass(type, actionName, cfg);
+    }
+    static fromClassWithProvider(type, serviceProvider, actionName, cfg) {
+        return actionFromClass(type, serviceProvider, actionName, cfg);
+    }
+}
+export function action(typeOrActionName, actionNameOrCfg, cfg) {
+    if (typeof typeOrActionName === 'string') {
+        return new ActionDescriptorInst(typeOrActionName, typeof actionNameOrCfg === 'string'
+            ? undefined
+            : {
+                ...actionNameOrCfg
+            });
+    }
+    else {
+        return new ActionDescriptorInst(typeof actionNameOrCfg === 'string' ? actionNameOrCfg : 'default', {
+            ...cfg
+        });
+    }
+}
+export function actionWithProvider(typeOrServiceProvider, serviceProviderOrActionName, actionNameOrCfg, cfg) {
+    const actionName = serviceProviderOrActionName === 'string' ? serviceProviderOrActionName : typeof actionNameOrCfg === 'string' ? actionNameOrCfg : 'default';
+    if (typeOrServiceProvider instanceof TypeDescriptor) {
+        return new ActionDescriptorInst(actionName, {
+            ...(typeof serviceProviderOrActionName === 'string' ? {} : actionGetProviderCfgObj(serviceProviderOrActionName)),
+            ...(typeof actionNameOrCfg === 'string' ? {} : actionNameOrCfg),
+            ...cfg
+        });
+    }
+    else {
+        return new ActionDescriptorInst(actionName, {
+            ...actionGetProviderCfgObj(typeOrServiceProvider),
+            ...cfg
+        });
+    }
+}
+export function actionFromModel(model, actionNameOrServiceProvider, cfgOrActionName, cfg) {
+    if (typeof actionNameOrServiceProvider === 'string') {
+        // no provider
+        return new ActionDescriptorInst(actionNameOrServiceProvider, {
+            model,
+            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),
+            ...cfg
+        });
+    }
+    else {
+        return new ActionDescriptorInst(typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {
+            model,
+            ...actionGetProviderCfgObj(actionNameOrServiceProvider),
+            ...cfg
+        });
+    }
+}
+export function actionFromClass(type, actionNameOrServiceProvider, cfgOrActionName, cfg) {
+    if (typeof actionNameOrServiceProvider === 'string') {
+        // no provider
+        const finalCfg = typeof cfgOrActionName === 'object' ? cfgOrActionName : cfg;
+        return new ActionDescriptorInst(actionNameOrServiceProvider, {
+            model: new ModelDescriptor(type, finalCfg?.idProperty, finalCfg?.titleProperty, finalCfg?.i18nBaseKey),
+            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),
+            ...cfg
+        });
+    }
+    else {
+        return new ActionDescriptorInst(typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {
+            model: new ModelDescriptor(type, cfg?.idProperty, cfg?.titleProperty, cfg?.i18nBaseKey),
+            ...actionGetProviderCfgObj(actionNameOrServiceProvider),
+            ...cfg
+        });
+    }
+}
+export class ActionDeleteDescriptor {
+    static create(model) {
+        return actionDelete(model);
+    }
+    static createWithProvider(model, serviceProvider) {
+        return actionDelete(model, serviceProvider);
+    }
+}
+export function actionDelete(model, serviceProvider) {
+    return new ActionDeleteDescriptorInst(model, {
+        ...(serviceProvider ? actionGetProviderCfgObj(serviceProvider) : {})
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-descriptor.factory.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/action/descriptors/action-descriptor.factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,8BAA8B,CAAC;AAE7E,OAAO,EAAC,0BAA0B,EAAgF,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAenK,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAiB,qBAA0D,EAAE,EAAE;IAClH,MAAM,GAAG,GAA2D,EAAE,CAAC;IACvE,IAAI,qBAAqB,EAAE,CAAC;QACxB,IAAK,qBAAuC,CAAC,cAAc,EAAE,CAAC;YAC1D,qFAAqF;YACrF,GAAG,CAAC,YAAY,GAAG,qBAAsD,CAAC;QAC9E,CAAC;aAAM,CAAC;YACJ,GAAG,CAAC,WAAW,GAAG,qBAAkD,CAAC;QACzE,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC,CAAC;AAEF,MAAM,OAAO,gBAAiB,SAAQ,oBAAyB;IAC3D;QACI,KAAK,CAAC,UAAU,CAAC,CAAC;IACtB,CAAC;IAEM,MAAM,CAAC,MAAM,CAAQ,UAAkB,EAAE,GAA0C;QACtF,OAAO,MAAM,CAAQ,UAAU,EAAE;YAC7B,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;IAEM,MAAM,CAAC,kBAAkB,CAC5B,eAAmD,EACnD,UAAkB,EAClB,GAA0C;QAE1C,OAAO,kBAAkB,CAAiB,eAAe,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IAChF,CAAC;IAEM,MAAM,CAAC,SAAS,CAAQ,KAA6B,EAAE,UAAkB,EAAE,GAA0C;QACxH,OAAO,eAAe,CAAQ,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IAC1D,CAAC;IAEM,MAAM,CAAC,qBAAqB,CAC/B,KAA6B,EAC7B,eAAmD,EACnD,UAAkB,EAClB,GAA0C;QAE1C,OAAO,eAAe,CAAiB,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACpF,CAAC;IAEM,MAAM,CAAC,SAAS,CAAQ,IAAsB,EAAE,UAAkB,EAAE,GAAgD;QACvH,OAAO,eAAe,CAAQ,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACzD,CAAC;IAEM,MAAM,CAAC,qBAAqB,CAC/B,IAAsB,EACtB,eAAmD,EACnD,UAAkB,EAClB,GAAgD;QAEhD,OAAO,eAAe,CAAiB,IAAI,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;IACnF,CAAC;CACJ;AAID,MAAM,UAAU,MAAM,CAClB,gBAAgD,EAChD,eAA+D,EAC/D,GAA0C;IAE1C,IAAI,OAAO,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QACvC,OAAO,IAAI,oBAAoB,CAC3B,gBAAgB,EAChB,OAAO,eAAe,KAAK,QAAQ;YAC/B,CAAC,CAAC,SAAS;YACX,CAAC,CAAC;gBACI,GAAG,eAAe;aACrB,CACV,CAAC;IACN,CAAC;SAAM,CAAC;QACJ,OAAO,IAAI,oBAAoB,CAAmB,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,EAAE;YACjH,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;AACL,CAAC;AAaD,MAAM,UAAU,kBAAkB,CAC9B,qBAAiF,EACjF,2BAAwE,EACxE,eAA+D,EAC/D,GAA0C;IAE1C,MAAM,UAAU,GAAG,2BAA2B,KAAK,QAAQ,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9J,IAAI,qBAAqB,YAAY,cAAc,EAAE,CAAC;QAClD,OAAO,IAAI,oBAAoB,CAAiB,UAAU,EAAE;YACxD,GAAG,CAAC,OAAO,2BAA2B,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,uBAAuB,CAAC,2BAA2B,CAAC,CAAC;YAChH,GAAG,CAAC,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC;YAC/D,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;SAAM,CAAC;QACJ,OAAO,IAAI,oBAAoB,CAAiB,UAAU,EAAE;YACxD,GAAG,uBAAuB,CAAC,qBAAqB,CAAC;YACjD,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;AACL,CAAC;AASD,MAAM,UAAU,eAAe,CAC3B,KAA6B,EAC7B,2BAAwE,EACxE,eAA+D,EAC/D,GAA0C;IAE1C,IAAI,OAAO,2BAA2B,KAAK,QAAQ,EAAE,CAAC;QAClD,cAAc;QACd,OAAO,IAAI,oBAAoB,CAAmB,2BAA2B,EAAE;YAC3E,KAAK;YACL,GAAG,CAAC,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;SAAM,CAAC;QACJ,OAAO,IAAI,oBAAoB,CAAiB,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,EAAE;YAC/G,KAAK;YACL,GAAG,uBAAuB,CAAC,2BAA2B,CAAC;YACvD,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;AACL,CAAC;AASD,MAAM,UAAU,eAAe,CAC3B,IAAsB,EACtB,2BAAwE,EACxE,eAAqE,EACrE,GAAgD;IAEhD,IAAI,OAAO,2BAA2B,KAAK,QAAQ,EAAE,CAAC;QAClD,cAAc;QACd,MAAM,QAAQ,GAAG,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC;QAC7E,OAAO,IAAI,oBAAoB,CAAiB,2BAA2B,EAAE;YACzE,KAAK,EAAE,IAAI,eAAe,CAAQ,IAAI,EAAE,QAAQ,EAAE,UAAoB,EAAE,QAAQ,EAAE,aAAuB,EAAE,QAAQ,EAAE,WAAW,CAAC;YACjI,GAAG,CAAC,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;SAAM,CAAC;QACJ,OAAO,IAAI,oBAAoB,CAAiB,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,EAAE;YAC/G,KAAK,EAAE,IAAI,eAAe,CAAQ,IAAI,EAAE,GAAG,EAAE,UAAoB,EAAE,GAAG,EAAE,aAAuB,EAAE,GAAG,EAAE,WAAW,CAAC;YAClH,GAAG,uBAAuB,CAAC,2BAA2B,CAAC;YACvD,GAAG,GAAG;SACT,CAAC,CAAC;IACP,CAAC;AACL,CAAC;AAED,MAAM,OAAO,sBAAsB;IACxB,MAAM,CAAC,MAAM,CAAQ,KAA6B;QACrD,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAEM,MAAM,CAAC,kBAAkB,CAC5B,KAA6B,EAC7B,eAAmD;QAEnD,OAAO,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;IAChD,CAAC;CACJ;AAID,MAAM,UAAU,YAAY,CAAiB,KAA6B,EAAE,eAAoD;IAC5H,OAAO,IAAI,0BAA0B,CAAiB,KAAK,EAAE;QACzD,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;KACvE,CAAC,CAAC;AACP,CAAC","sourcesContent":["import {ClassType, IDataProvider, ServiceClassType} from '@mediusinc/mng-commons/core';\nimport {ModelDescriptor, TypeDescriptor} from '@mediusinc/mng-commons/model';\n\nimport {ActionDeleteDescriptorInst, ActionDescriptorCreateOptsParentType, ActionDescriptorCreateOptsProviderType, ActionDescriptorInst} from './action.descriptor';\n\nexport type ActionDescriptorCreateFromClassOpts<Model> = ActionDescriptorCreateOptsModel<Model> & ActionDescriptorCreateOptsI18nType & ActionDescriptorCreateOptsParentType;\n\nexport type ActionDescriptorCreateOptsI18nType = {\n    i18nBaseKey?: string | ClassType<any>;\n};\n\nexport type ActionDescriptorCreateOptsModel<Model> = {\n    idProperty?: keyof Model;\n    titleProperty?: keyof Model;\n};\n\nexport type ActionProviderType<Model, Service> = ServiceClassType<Service> | IDataProvider<Model, Service>;\n\nexport const actionGetProviderCfgObj = <Model, Service>(serviceOrDataProvider?: ActionProviderType<Model, Service>) => {\n    const cfg: ActionDescriptorCreateOptsProviderType<Model, Service> = {};\n    if (serviceOrDataProvider) {\n        if ((serviceOrDataProvider as IDataProvider).isDataProvider) {\n            // type casting needed, cause there was no other way found to differentiate the types\n            cfg.dataProvider = serviceOrDataProvider as IDataProvider<Model, Service>;\n        } else {\n            cfg.serviceType = serviceOrDataProvider as ServiceClassType<Service>;\n        }\n    }\n    return cfg;\n};\n\nexport class ActionDescriptor extends ActionDescriptorInst<any> {\n    protected constructor() {\n        super('internal');\n    }\n\n    public static create<Model>(actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, undefined> {\n        return action<Model>(actionName, {\n            ...cfg\n        });\n    }\n\n    public static createWithProvider<Model, Service>(\n        serviceProvider: ActionProviderType<Model, Service>,\n        actionName: string,\n        cfg?: ActionDescriptorCreateOptsParentType\n    ): ActionDescriptorInst<Model, Service> {\n        return actionWithProvider<Model, Service>(serviceProvider, actionName, cfg);\n    }\n\n    public static fromModel<Model>(model: ModelDescriptor<Model>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, undefined> {\n        return actionFromModel<Model>(model, actionName, cfg);\n    }\n\n    public static fromModelWithProvider<Model, Service>(\n        model: ModelDescriptor<Model>,\n        serviceProvider: ActionProviderType<Model, Service>,\n        actionName: string,\n        cfg?: ActionDescriptorCreateOptsParentType\n    ): ActionDescriptorInst<Model, Service> {\n        return actionFromModel<Model, Service>(model, serviceProvider, actionName, cfg);\n    }\n\n    public static fromClass<Model>(type: ClassType<Model>, actionName: string, cfg?: ActionDescriptorCreateFromClassOpts<Model>): ActionDescriptorInst<Model, undefined> {\n        return actionFromClass<Model>(type, actionName, cfg);\n    }\n\n    public static fromClassWithProvider<Model, Service>(\n        type: ClassType<Model>,\n        serviceProvider: ActionProviderType<Model, Service>,\n        actionName: string,\n        cfg?: ActionDescriptorCreateFromClassOpts<Model>\n    ): ActionDescriptorInst<Model, Service> {\n        return actionFromClass<Model, Service>(type, serviceProvider, actionName, cfg);\n    }\n}\n\nexport function action<Model>(actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, undefined>;\nexport function action<Model>(type: TypeDescriptor<Model>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, undefined>;\nexport function action<Model>(\n    typeOrActionName: TypeDescriptor<Model> | string,\n    actionNameOrCfg?: string | ActionDescriptorCreateOptsParentType,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionDescriptorInst<Model, undefined> {\n    if (typeof typeOrActionName === 'string') {\n        return new ActionDescriptorInst<Model, undefined>(\n            typeOrActionName,\n            typeof actionNameOrCfg === 'string'\n                ? undefined\n                : {\n                      ...actionNameOrCfg\n                  }\n        );\n    } else {\n        return new ActionDescriptorInst<Model, undefined>(typeof actionNameOrCfg === 'string' ? actionNameOrCfg : 'default', {\n            ...cfg\n        });\n    }\n}\n\nexport function actionWithProvider<Model, Service>(\n    serviceProvider: ActionProviderType<Model, Service>,\n    actionName: string,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionDescriptorInst<Model, Service>;\nexport function actionWithProvider<Model, Service>(\n    type: TypeDescriptor<Model>,\n    serviceProvider: ActionProviderType<Model, Service>,\n    actionName: string,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionDescriptorInst<Model, Service>;\nexport function actionWithProvider<Model, Service>(\n    typeOrServiceProvider: TypeDescriptor<Model> | ActionProviderType<Model, Service>,\n    serviceProviderOrActionName: ActionProviderType<Model, Service> | string,\n    actionNameOrCfg?: string | ActionDescriptorCreateOptsParentType,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionDescriptorInst<Model, Service> {\n    const actionName = serviceProviderOrActionName === 'string' ? serviceProviderOrActionName : typeof actionNameOrCfg === 'string' ? actionNameOrCfg : 'default';\n    if (typeOrServiceProvider instanceof TypeDescriptor) {\n        return new ActionDescriptorInst<Model, Service>(actionName, {\n            ...(typeof serviceProviderOrActionName === 'string' ? {} : actionGetProviderCfgObj(serviceProviderOrActionName)),\n            ...(typeof actionNameOrCfg === 'string' ? {} : actionNameOrCfg),\n            ...cfg\n        });\n    } else {\n        return new ActionDescriptorInst<Model, Service>(actionName, {\n            ...actionGetProviderCfgObj(typeOrServiceProvider),\n            ...cfg\n        });\n    }\n}\n\nexport function actionFromModel<Model>(model: ModelDescriptor<Model>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType): ActionDescriptorInst<Model, undefined>;\nexport function actionFromModel<Model, Service>(\n    model: ModelDescriptor<Model>,\n    serviceProvider: ActionProviderType<Model, Service>,\n    actionName: string,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionDescriptorInst<Model, Service>;\nexport function actionFromModel<Model, Service>(\n    model: ModelDescriptor<Model>,\n    actionNameOrServiceProvider: string | ActionProviderType<Model, Service>,\n    cfgOrActionName?: string | ActionDescriptorCreateOptsParentType,\n    cfg?: ActionDescriptorCreateOptsParentType\n) {\n    if (typeof actionNameOrServiceProvider === 'string') {\n        // no provider\n        return new ActionDescriptorInst<Model, undefined>(actionNameOrServiceProvider, {\n            model,\n            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),\n            ...cfg\n        });\n    } else {\n        return new ActionDescriptorInst<Model, Service>(typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {\n            model,\n            ...actionGetProviderCfgObj(actionNameOrServiceProvider),\n            ...cfg\n        });\n    }\n}\n\nexport function actionFromClass<Model>(type: ClassType<Model>, actionName: string, cfg?: ActionDescriptorCreateFromClassOpts<Model>): ActionDescriptorInst<Model, undefined>;\nexport function actionFromClass<Model, Service>(\n    type: ClassType<Model>,\n    serviceProvider: ActionProviderType<Model, Service>,\n    actionName: string,\n    cfg?: ActionDescriptorCreateFromClassOpts<Model>\n): ActionDescriptorInst<Model, Service>;\nexport function actionFromClass<Model, Service>(\n    type: ClassType<Model>,\n    actionNameOrServiceProvider: string | ActionProviderType<Model, Service>,\n    cfgOrActionName?: string | ActionDescriptorCreateFromClassOpts<Model>,\n    cfg?: ActionDescriptorCreateFromClassOpts<Model>\n): ActionDescriptorInst<Model, Service> {\n    if (typeof actionNameOrServiceProvider === 'string') {\n        // no provider\n        const finalCfg = typeof cfgOrActionName === 'object' ? cfgOrActionName : cfg;\n        return new ActionDescriptorInst<Model, Service>(actionNameOrServiceProvider, {\n            model: new ModelDescriptor<Model>(type, finalCfg?.idProperty as string, finalCfg?.titleProperty as string, finalCfg?.i18nBaseKey),\n            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),\n            ...cfg\n        });\n    } else {\n        return new ActionDescriptorInst<Model, Service>(typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {\n            model: new ModelDescriptor<Model>(type, cfg?.idProperty as string, cfg?.titleProperty as string, cfg?.i18nBaseKey),\n            ...actionGetProviderCfgObj(actionNameOrServiceProvider),\n            ...cfg\n        });\n    }\n}\n\nexport class ActionDeleteDescriptor {\n    public static create<Model>(model: ModelDescriptor<Model>): ActionDeleteDescriptorInst<Model, undefined> {\n        return actionDelete(model);\n    }\n\n    public static createWithProvider<Model, Service>(\n        model: ModelDescriptor<Model>,\n        serviceProvider: ActionProviderType<Model, Service>\n    ): ActionDeleteDescriptorInst<Model, Service> {\n        return actionDelete(model, serviceProvider);\n    }\n}\n\nexport function actionDelete<Model>(model: ModelDescriptor<Model>): ActionDeleteDescriptorInst<Model, undefined>;\nexport function actionDelete<Model, Service>(model: ModelDescriptor<Model>, serviceProvider: ActionProviderType<Model, Service>): ActionDeleteDescriptorInst<Model, Service>;\nexport function actionDelete<Model, Service>(model: ModelDescriptor<Model>, serviceProvider?: ActionProviderType<Model, Service>): ActionDeleteDescriptorInst<Model, Service> {\n    return new ActionDeleteDescriptorInst<Model, Service>(model, {\n        ...(serviceProvider ? actionGetProviderCfgObj(serviceProvider) : {})\n    });\n}\n"]}

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

@@ -0,0 +1,77 @@
+import { ActionEditorAddDescriptorInst, ActionEditorDescriptorInst, ActionEditorDetailsDescriptorInst, ActionEditorEditDescriptorInst } from './action-editor.descriptor';
+export const actionEditorGetProviderCfgObj = (serviceOrDataProvider) => {
+    const cfg = {};
+    if (serviceOrDataProvider) {
+        if (serviceOrDataProvider.isDataProvider) {
+            // type casting needed, cause there was no other way found to differentiate the types
+            cfg.dataProvider = serviceOrDataProvider;
+        }
+        else {
+            cfg.serviceType = serviceOrDataProvider;
+        }
+    }
+    return cfg;
+};
+export class ActionEditorDescriptor {
+    static create(editor, actionName, cfg) {
+        return actionEditor(editor, actionName, cfg);
+    }
+    static createWithProvider(editor, serviceProvider, actionName, cfg) {
+        return actionEditor(editor, serviceProvider, actionName, cfg);
+    }
+}
+export function actionEditor(editor, actionNameOrServiceProvider, cfgOrActionName, cfg) {
+    if (typeof actionNameOrServiceProvider === 'string') {
+        // no provider
+        return new ActionEditorDescriptorInst(editor, actionNameOrServiceProvider, {
+            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),
+            ...cfg
+        });
+    }
+    else {
+        return new ActionEditorDescriptorInst(editor, typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {
+            ...actionEditorGetProviderCfgObj(actionNameOrServiceProvider),
+            ...cfg
+        });
+    }
+}
+export class ActionEditorDetailsDescriptor {
+    static create(editor) {
+        return actionEditorDetails(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return actionEditorDetails(editor, serviceProvider);
+    }
+}
+export function actionEditorDetails(editor, serviceProvider) {
+    return new ActionEditorDetailsDescriptorInst(editor, {
+        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})
+    });
+}
+export class ActionEditorAddDescriptor {
+    static create(editor) {
+        return actionEditorAdd(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return actionEditorAdd(editor, serviceProvider);
+    }
+}
+export function actionEditorAdd(editor, serviceProvider) {
+    return new ActionEditorAddDescriptorInst(editor, {
+        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})
+    });
+}
+export class ActionEditorEditDescriptor {
+    static create(editor) {
+        return actionEditorEdit(editor);
+    }
+    static createWithProvider(editor, serviceProvider) {
+        return actionEditorEdit(editor, serviceProvider);
+    }
+}
+export function actionEditorEdit(editor, serviceProvider) {
+    return new ActionEditorEditDescriptorInst(editor, {
+        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-editor-descriptor.factory.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/action/descriptors/action-editor-descriptor.factory.ts"],"names":[],"mappings":"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","sourcesContent":["import {ServiceClassType} from '@mediusinc/mng-commons/core';\n\nimport {IEditorDataProvider} from '../../editor/data-providers/editor.data-provider';\nimport {EditorDescriptorInst} from '../../editor/descriptors/editor.descriptor';\nimport {\n    ActionEditorAddDescriptorInst,\n    ActionEditorDescriptorCreateOptsProviderType,\n    ActionEditorDescriptorInst,\n    ActionEditorDetailsDescriptorInst,\n    ActionEditorEditDescriptorInst\n} from './action-editor.descriptor';\nimport {ActionDescriptorCreateOptsParentType} from './action.descriptor';\n\nexport type ActionEditorProviderType<Model, Service> = ServiceClassType<Service> | IEditorDataProvider<Model, Service>;\n\nexport const actionEditorGetProviderCfgObj = <Model, Service>(serviceOrDataProvider?: ActionEditorProviderType<Model, Service>) => {\n    const cfg: ActionEditorDescriptorCreateOptsProviderType<Model, Service> = {};\n    if (serviceOrDataProvider) {\n        if ((serviceOrDataProvider as IEditorDataProvider).isDataProvider) {\n            // type casting needed, cause there was no other way found to differentiate the types\n            cfg.dataProvider = serviceOrDataProvider as IEditorDataProvider<Model, Service>;\n        } else {\n            cfg.serviceType = serviceOrDataProvider as ServiceClassType<Service>;\n        }\n    }\n    return cfg;\n};\n\nexport class ActionEditorDescriptor {\n    public static create<Model>(\n        editor: EditorDescriptorInst<Model, any>,\n        actionName: string,\n        cfg?: ActionDescriptorCreateOptsParentType\n    ): ActionEditorDescriptorInst<Model, undefined> {\n        return actionEditor(editor, actionName, cfg);\n    }\n\n    public static createWithProvider<Model, Service>(\n        editor: EditorDescriptorInst<Model, any>,\n        serviceProvider: ActionEditorProviderType<Model, Service>,\n        actionName: string,\n        cfg?: ActionDescriptorCreateOptsParentType\n    ): ActionEditorDescriptorInst<Model, Service> {\n        return actionEditor(editor, serviceProvider, actionName, cfg);\n    }\n}\n\nexport function actionEditor<Model>(\n    editor: EditorDescriptorInst<Model, any>,\n    actionName: string,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionEditorDescriptorInst<Model, undefined>;\nexport function actionEditor<Model, Service>(\n    editor: EditorDescriptorInst<Model, any>,\n    serviceProvider: ActionEditorProviderType<Model, Service>,\n    actionName: string,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionEditorDescriptorInst<Model, Service>;\nexport function actionEditor<Model, Service>(\n    editor: EditorDescriptorInst<Model, Service>,\n    actionNameOrServiceProvider: string | ActionEditorProviderType<Model, Service>,\n    cfgOrActionName?: string | ActionDescriptorCreateOptsParentType,\n    cfg?: ActionDescriptorCreateOptsParentType\n): ActionEditorDescriptorInst<Model, Service> {\n    if (typeof actionNameOrServiceProvider === 'string') {\n        // no provider\n        return new ActionEditorDescriptorInst<Model, Service>(editor, actionNameOrServiceProvider, {\n            ...(typeof cfgOrActionName === 'object' ? cfgOrActionName : {}),\n            ...cfg\n        });\n    } else {\n        return new ActionEditorDescriptorInst<Model, Service>(editor, typeof cfgOrActionName === 'string' ? cfgOrActionName : 'default', {\n            ...actionEditorGetProviderCfgObj(actionNameOrServiceProvider),\n            ...cfg\n        });\n    }\n}\n\nexport class ActionEditorDetailsDescriptor {\n    public static create<Model>(editor: EditorDescriptorInst<Model, any>): ActionEditorDescriptorInst<Model, undefined> {\n        return actionEditorDetails(editor);\n    }\n\n    public static createWithProvider<Model, Service>(\n        editor: EditorDescriptorInst<Model, any>,\n        serviceProvider: ActionEditorProviderType<Model, Service>\n    ): ActionEditorDescriptorInst<Model, Service> {\n        return actionEditorDetails(editor, serviceProvider);\n    }\n}\n\nexport function actionEditorDetails<Model>(editor: EditorDescriptorInst<Model, any>): ActionEditorDetailsDescriptorInst<Model, undefined>;\nexport function actionEditorDetails<Model, Service>(\n    editor: EditorDescriptorInst<Model, any>,\n    serviceProvider: ActionEditorProviderType<Model, Service>\n): ActionEditorDetailsDescriptorInst<Model, Service>;\nexport function actionEditorDetails<Model, Service>(\n    editor: EditorDescriptorInst<Model, any>,\n    serviceProvider?: ActionEditorProviderType<Model, Service>\n): ActionEditorDetailsDescriptorInst<Model, Service> {\n    return new ActionEditorDetailsDescriptorInst<Model, Service>(editor, {\n        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})\n    });\n}\n\nexport class ActionEditorAddDescriptor {\n    public static create<Model>(editor: EditorDescriptorInst<Model, any>): ActionEditorAddDescriptorInst<Model, undefined> {\n        return actionEditorAdd(editor);\n    }\n\n    public static createWithProvider<Model, Service>(\n        editor: EditorDescriptorInst<Model, any>,\n        serviceProvider: ActionEditorProviderType<Model, Service>\n    ): ActionEditorAddDescriptorInst<Model, Service> {\n        return actionEditorAdd(editor, serviceProvider);\n    }\n}\n\nexport function actionEditorAdd<Model>(editor: EditorDescriptorInst<Model, any>): ActionEditorDetailsDescriptorInst<Model, undefined>;\nexport function actionEditorAdd<Model, Service>(\n    editor: EditorDescriptorInst<Model, any>,\n    serviceProvider: ActionEditorProviderType<Model, Service>\n): ActionEditorAddDescriptorInst<Model, Service>;\nexport function actionEditorAdd<Model, Service>(\n    editor: EditorDescriptorInst<Model, any>,\n    serviceProvider?: ActionEditorProviderType<Model, Service>\n): ActionEditorAddDescriptorInst<Model, Service> {\n    return new ActionEditorAddDescriptorInst<Model, Service>(editor, {\n        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})\n    });\n}\n\nexport class ActionEditorEditDescriptor {\n    public static create<Model>(editor: EditorDescriptorInst<Model, any>): ActionEditorEditDescriptorInst<Model, undefined> {\n        return actionEditorEdit(editor);\n    }\n\n    public static createWithProvider<Model, Service>(\n        editor: EditorDescriptorInst<Model, any>,\n        serviceProvider: ActionEditorProviderType<Model, Service>\n    ): ActionEditorEditDescriptorInst<Model, Service> {\n        return actionEditorEdit(editor, serviceProvider);\n    }\n}\n\nexport function actionEditorEdit<Model>(editor: EditorDescriptorInst<Model, any>): ActionEditorDetailsDescriptorInst<Model, undefined>;\nexport function actionEditorEdit<Model, Service>(\n    editor: EditorDescriptorInst<Model, any>,\n    serviceProvider: ActionEditorProviderType<Model, Service>\n): ActionEditorEditDescriptorInst<Model, Service>;\nexport function actionEditorEdit<Model, Service>(\n    editor: EditorDescriptorInst<Model, any>,\n    serviceProvider?: ActionEditorProviderType<Model, Service>\n): ActionEditorEditDescriptorInst<Model, Service> {\n    return new ActionEditorEditDescriptorInst<Model, Service>(editor, {\n        ...(serviceProvider ? actionEditorGetProviderCfgObj(serviceProvider) : {})\n    });\n}\n"]}

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

@@ -1,22 +1,9 @@
 import { CommonsInternalError, StyleSizeEnum } from '@mediusinc/mng-commons/core';
 import { ActionButtonDescriptor, ButtonStyleBuilder } from '@mediusinc/mng-commons/form/api';
-import { EditorDataProvider } from '../../editor/data-providers/editor.data-provider';
+import { EditorDataProviderInst } from '../../editor/data-providers/editor.data-provider';
 import { ActionEditorSubmitTypeEnum, ActionPositionEnum, ActionTypeEnum } from '../models/action.type';
 import { TableviewActionDefaultCategories } from '../models/tableview-action-default-categories.model';
 import { ActionDescriptorInst } from './action.descriptor';
-export const actionEditorGetProviderCfgObj = (serviceOrDataProvider) => {
-    const cfg = {};
-    if (serviceOrDataProvider) {
-        if (serviceOrDataProvider.isDataProvider) {
-            // type casting needed, cause there was no other way found to differentiate the types
-            cfg.dataProvider = serviceOrDataProvider;
-        }
-        else {
-            cfg.serviceType = serviceOrDataProvider;
-        }
-    }
-    return cfg;
-};
 export class ActionEditorDescriptorInst extends ActionDescriptorInst {
     constructor(editorDescriptor, actionName, cfg) {
         super(actionName, {
@@ -32,14 +19,14 @@ export class ActionEditorDescriptorInst extends ActionDescriptorInst {
         this._resubmitRefetch = true;
         this._unsavedChangesConfirmation = false;
         if (cfg?.serviceType) {
-            this._dataProvider = EditorDataProvider.fromAnyParam(this._model?.type, cfg.serviceType);
+            this._dataProvider = new EditorDataProviderInst(this._model?.type, cfg.serviceType);
         }
         else if (cfg?.dataProvider) {
             this._dataProvider = cfg.dataProvider;
         }
         this._type = ActionTypeEnum.Editor;
         this._editorDescriptor = editorDescriptor;
-        this._editorActions.push(ActionEditorSubmitDescriptor.forPrimary(this), ActionEditorSubmitDescriptor.forSecondary(this));
+        this._editorActions.push(actionEditorSubmit(this), actionEditorCancel(this));
     }
     get editorTitle() {
         return this._editorTitle;
@@ -161,21 +148,6 @@ export class ActionEditorDescriptorInst extends ActionDescriptorInst {
         return this;
     }
 }
-export class ActionEditorDescriptor {
-    static create(editor, actionName, cfg) {
-        return new ActionEditorDescriptorInst(editor, actionName, {
-            parentType: cfg?.parentType,
-            parentProperty: cfg?.parentProperty
-        });
-    }
-    static createWithProvider(editor, serviceProvider, actionName, cfg) {
-        return new ActionEditorDescriptorInst(editor, actionName, {
-            ...actionEditorGetProviderCfgObj(serviceProvider),
-            parentType: cfg?.parentType,
-            parentProperty: cfg?.parentProperty
-        });
-    }
-}
 export class ActionEditorSubmitDescriptorInst extends ActionDescriptorInst {
     constructor(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
         super(submitType === ActionEditorSubmitTypeEnum.Submit ? `${editorAction.actionName}.submit` : `${editorAction.actionName}.cancel`, { model: editorAction.model });
@@ -188,23 +160,21 @@ export class ActionEditorSubmitDescriptorInst extends ActionDescriptorInst {
         return this._submitType;
     }
 }
-export class ActionEditorSubmitDescriptor {
-    /**
-     * creates primary action with primary button style
-     * @param editorAction
-     * @param submitType
-     */
-    static forPrimary(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
-        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder()));
-    }
-    /**
-     * creates secondary button with text button style
-     * @param editorAction
-     * @param submitType
-     */
-    static forSecondary(editorAction, submitType = ActionEditorSubmitTypeEnum.Cancel) {
-        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton()));
-    }
+/**
+ * creates primary action with primary button style
+ * @param editorAction
+ * @param submitType
+ */
+export function actionEditorSubmit(editorAction, submitType = ActionEditorSubmitTypeEnum.Submit) {
+    return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder()));
+}
+/**
+ * creates secondary button with text button style
+ * @param editorAction
+ * @param submitType
+ */
+export function actionEditorCancel(editorAction, submitType = ActionEditorSubmitTypeEnum.Cancel) {
+    return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton()));
 }
 export class ActionEditorDetailsDescriptorInst extends ActionEditorDescriptorInst {
     static { this.ACTION_NAME = 'details'; }
@@ -212,20 +182,10 @@ export class ActionEditorDetailsDescriptorInst extends ActionEditorDescriptorIns
         super(editorDescriptor, ActionEditorDetailsDescriptorInst.ACTION_NAME, cfg);
         this.withPosition(ActionPositionEnum.RowClick);
         this.withRouteTrigger(':itemId');
-        this.withEditorActions([ActionEditorSubmitDescriptor.forSecondary(this, ActionEditorSubmitTypeEnum.Cancel)]);
+        this.withEditorActions([actionEditorCancel(this)]);
         this.withTableviewCategory(TableviewActionDefaultCategories.DETAILS);
     }
 }
-export class ActionEditorDetailsDescriptor {
-    static create(editor) {
-        return new ActionEditorDetailsDescriptorInst(editor);
-    }
-    static createWithProvider(editor, serviceProvider) {
-        return new ActionEditorDetailsDescriptorInst(editor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        });
-    }
-}
 export class ActionEditorAddDescriptorInst extends ActionEditorDescriptorInst {
     static { this.ACTION_NAME = 'add'; }
     constructor(editorDescriptor, cfg) {
@@ -237,16 +197,6 @@ export class ActionEditorAddDescriptorInst extends ActionEditorDescriptorInst {
         this.withUnsavedChangesConfirmation();
     }
 }
-export class ActionEditorAddDescriptor {
-    static create(editor) {
-        return new ActionEditorAddDescriptorInst(editor);
-    }
-    static createWithProvider(editor, serviceProvider) {
-        return new ActionEditorAddDescriptorInst(editor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        });
-    }
-}
 export class ActionEditorEditDescriptorInst extends ActionEditorDescriptorInst {
     static { this.ACTION_NAME = 'edit'; }
     constructor(editorDescriptor, cfg) {
@@ -259,14 +209,4 @@ export class ActionEditorEditDescriptorInst extends ActionEditorDescriptorInst {
         this.withUnsavedChangesConfirmation();
     }
 }
-export class ActionEditorEditDescriptor {
-    static create(editor) {
-        return new ActionEditorEditDescriptorInst(editor);
-    }
-    static createWithProvider(editor, serviceProvider) {
-        return new ActionEditorEditDescriptorInst(editor, {
-            ...actionEditorGetProviderCfgObj(serviceProvider)
-        });
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-editor.descriptor.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/action/descriptors/action-editor.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\n\nimport {Observable} from 'rxjs';\n\nimport {CommonsInternalError, ServiceClassType, StyleSizeEnum} from '@mediusinc/mng-commons/core';\nimport {ActionButtonDescriptor, ButtonStyleBuilder} from '@mediusinc/mng-commons/form/api';\nimport {ModelDescriptor} from '@mediusinc/mng-commons/model';\n\nimport {EditorDataProvider, IEditorDataProvider} from '../../editor/data-providers/editor.data-provider';\nimport {EditorDescriptorInst} from '../../editor/descriptors/editor.descriptor';\nimport {ActionEditorSubmitTypeEnum, ActionPositionEnum, ActionTypeEnum} from '../models/action.type';\nimport {IActionContext} from '../models/execution/action-context.model';\nimport {TableviewActionDefaultCategories} from '../models/tableview-action-default-categories.model';\nimport {ActionDescriptorCreateOptsParentType, ActionDescriptorInst} from './action.descriptor';\n\nexport type ActionEditorDescriptorConstructorOptsType<Model, Service> = ActionDescriptorCreateOptsParentType &\n    ActionEditorDescriptorCreateOptsProviderType<Model, Service> & {\n        model?: ModelDescriptor<Model>;\n    };\n\nexport type ActionEditorDescriptorCreateOptsProviderType<Model, Service> = {\n    serviceType?: ServiceClassType<Service>;\n    dataProvider?: IEditorDataProvider<Model, Service>;\n};\n\nexport type ActionEditorProviderType<Model, Service> = ServiceClassType<Service> | IEditorDataProvider<Model, Service>;\n\nexport const actionEditorGetProviderCfgObj = <Model, Service>(serviceOrDataProvider?: ActionEditorProviderType<Model, Service>) => {\n    const cfg: ActionEditorDescriptorCreateOptsProviderType<Model, Service> = {};\n    if (serviceOrDataProvider) {\n        if ((serviceOrDataProvider as IEditorDataProvider).isDataProvider) {\n            // type casting needed, cause there was no other way found to differentiate the types\n            cfg.dataProvider = serviceOrDataProvider as IEditorDataProvider<Model, Service>;\n        } else {\n            cfg.serviceType = serviceOrDataProvider as ServiceClassType<Service>;\n        }\n    }\n    return cfg;\n};\n\nexport class ActionEditorDescriptorInst<Item, Service = any> extends ActionDescriptorInst<Item, Service> {\n    private readonly _editorDescriptor: EditorDescriptorInst<Item>;\n    protected override readonly _dataProvider?: IEditorDataProvider<Item, any> = undefined;\n\n    protected _editorActions: ActionDescriptorInst<Item>[] = [];\n    protected _editorTitle?: string | null = undefined;\n    protected _editorTitleParams?: any = undefined;\n\n    protected _hasFetchNotificationSuccess = false;\n    protected _fetchNotificationSuccessTitle?: string;\n    protected _fetchNotificationSuccessMessage?: string;\n\n    protected _dialogSize = StyleSizeEnum.Normal;\n    protected _dialogClassName?: string;\n\n    protected _fetchFunction?: (ctx: IActionContext<Item, Service>) => Observable<Item>;\n    protected _submitFunction?: (ctx: IActionContext<Item, Service>) => Observable<Item>;\n\n    protected _editorComponent?: Type<any>;\n\n    protected _resubmitEnabled?: boolean;\n    protected _resubmitRefetch = true;\n    protected _unsavedChangesConfirmation = false;\n\n    public constructor(editorDescriptor: EditorDescriptorInst<Item>, actionName: string, cfg?: ActionEditorDescriptorConstructorOptsType<Item, Service>) {\n        super(actionName, {\n            model: editorDescriptor.model,\n            ...cfg\n        });\n\n        if (cfg?.serviceType) {\n            this._dataProvider = EditorDataProvider.fromAnyParam<Item, Service>(this._model?.type, cfg.serviceType);\n        } else if (cfg?.dataProvider) {\n            this._dataProvider = cfg.dataProvider;\n        }\n\n        this._type = ActionTypeEnum.Editor;\n        this._editorDescriptor = editorDescriptor;\n        this._editorActions.push(ActionEditorSubmitDescriptor.forPrimary(this), ActionEditorSubmitDescriptor.forSecondary(this));\n    }\n\n    public get editorTitle() {\n        return this._editorTitle;\n    }\n\n    public get editorTitleParams() {\n        return this._editorTitleParams;\n    }\n\n    public get editorDescriptor() {\n        return this._editorDescriptor;\n    }\n\n    public get dialogSize() {\n        return this._dialogSize;\n    }\n\n    public get dialogClassName() {\n        return this._dialogClassName;\n    }\n\n    public get hasFetchNotificationSuccess() {\n        return this._hasFetchNotificationSuccess;\n    }\n\n    public get fetchNotificationSuccessTitle() {\n        return this._fetchNotificationSuccessTitle;\n    }\n\n    public get fetchNotificationSuccessMessage() {\n        return this._fetchNotificationSuccessMessage;\n    }\n\n    public override get dataProvider() {\n        return this._dataProvider;\n    }\n\n    public override get hasRunFunction(): boolean {\n        throw new CommonsInternalError(`Run function cannot be used in editor action for ${this._actionNameLong}. Use submit function instead`);\n    }\n\n    public override get runFunction(): (ctx: IActionContext<Item, unknown>) => Observable<Item> {\n        throw new CommonsInternalError(`Run function cannot be used in editor action for ${this._actionNameLong}. Use submit function instead`);\n    }\n\n    public get hasFetchFunction(): boolean {\n        return typeof this._fetchFunction === 'function';\n    }\n\n    public get fetchFunction() {\n        return this._fetchFunction;\n    }\n\n    public get hasSubmitFunction(): boolean {\n        return typeof this._fetchFunction === 'function';\n    }\n\n    public get submitFunction() {\n        return this._submitFunction;\n    }\n\n    public get editorActions() {\n        return this._editorActions;\n    }\n\n    public get editorComponent() {\n        return this._editorComponent;\n    }\n\n    public get resubmitEnabled() {\n        return this._resubmitEnabled;\n    }\n\n    public get resubmitRefetch() {\n        return this._resubmitRefetch;\n    }\n\n    public get unsavedChangesConfirmation() {\n        return this._unsavedChangesConfirmation;\n    }\n\n    public withEditorTitle(title: string | null, params?: any): this {\n        this._editorTitle = title;\n        this._editorTitleParams = params;\n        return this;\n    }\n\n    public withDialogSize(size = StyleSizeEnum.Normal): this {\n        this._dialogSize = size;\n        return this;\n    }\n\n    public withDialogClassName(className: string): this {\n        this._dialogClassName = className;\n        return this;\n    }\n\n    public override withRunFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this {\n        return this.withSubmitFunction(fn as (ctx: IActionContext<Item, Service>) => Observable<Item>);\n    }\n\n    public withFetchFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this {\n        this._fetchFunction = fn;\n        return this;\n    }\n\n    public withSubmitFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this {\n        this._submitFunction = fn;\n        return this;\n    }\n\n    public withFetchNotificationError(title?: string, message?: string, hasNotification = true): this {\n        this._hasFetchNotificationSuccess = hasNotification;\n        this._fetchNotificationSuccessTitle = title;\n        this._fetchNotificationSuccessMessage = message;\n        return this;\n    }\n\n    public withEditorAction(action: ActionDescriptorInst<Item>): this {\n        this._editorActions.push(action);\n        return this;\n    }\n\n    public withEditorActions(actions: ActionDescriptorInst<Item>[]): this {\n        this._editorActions = actions;\n        return this;\n    }\n\n    public withEditorComponent(editorComponent: Type<any>): this {\n        this._editorComponent = editorComponent;\n        return this;\n    }\n\n    /**\n     * Enables or disables resubmit resubmit - this means the form will not exit after successful submission, but will instead remain open.\n     *\n     * @param {boolean} [enabled=true] - Specifies whether resubmit is enabled or disabled. Defaults to true if not provided.\n     * @param {boolean} [refetch=true] - Specifies whether the data should be refetched after resubmit. If not, the data in the form stays as is. Defaults to true if not provided.\n     *\n     * @returns {this} - Returns the current instance with the resubmit configuration updated.\n     */\n    public withResubmit(enabled?: boolean, refetch = true): this {\n        this._resubmitEnabled = enabled;\n        this._resubmitRefetch = refetch;\n        return this;\n    }\n\n    public withUnsavedChangesConfirmation(unsavedChangesConfirmation = true): this {\n        this._unsavedChangesConfirmation = unsavedChangesConfirmation;\n        return this;\n    }\n}\n\nexport class ActionEditorDescriptor {\n    public static create<Model>(editor: EditorDescriptorInst<Model>, actionName: string, cfg?: ActionDescriptorCreateOptsParentType) {\n        return new ActionEditorDescriptorInst<Model, undefined>(editor, actionName, {\n            parentType: cfg?.parentType,\n            parentProperty: cfg?.parentProperty\n        });\n    }\n\n    public static createWithProvider<Model, Service>(\n        editor: EditorDescriptorInst<Model>,\n        serviceProvider: ActionEditorProviderType<Model, Service>,\n        actionName: string,\n        cfg?: ActionDescriptorCreateOptsParentType\n    ) {\n        return new ActionEditorDescriptorInst(editor, actionName, {\n            ...actionEditorGetProviderCfgObj(serviceProvider),\n            parentType: cfg?.parentType,\n            parentProperty: cfg?.parentProperty\n        });\n    }\n}\n\nexport class ActionEditorSubmitDescriptorInst<Model> extends ActionDescriptorInst<Model> {\n    private readonly _editorAction: ActionEditorDescriptorInst<Model>;\n    private readonly _submitType: ActionEditorSubmitTypeEnum;\n\n    constructor(editorAction: ActionEditorDescriptorInst<Model>, submitType = ActionEditorSubmitTypeEnum.Submit) {\n        super(submitType === ActionEditorSubmitTypeEnum.Submit ? `${editorAction.actionName}.submit` : `${editorAction.actionName}.cancel`, {model: editorAction.model});\n        this._editorAction = editorAction;\n        this._submitType = submitType;\n        this._position = ActionPositionEnum.FooterRight;\n\n        this.button.styleClass.withActionLevel(editorAction.level).withTextButton();\n    }\n\n    public get submitType() {\n        return this._submitType;\n    }\n}\n\nexport class ActionEditorSubmitDescriptor {\n    /**\n     * creates primary action with primary button style\n     * @param editorAction\n     * @param submitType\n     */\n    static forPrimary<Model>(editorAction: ActionEditorDescriptorInst<Model>, submitType = ActionEditorSubmitTypeEnum.Submit): ActionEditorSubmitDescriptorInst<Model> {\n        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder()));\n    }\n\n    /**\n     * creates secondary button with text button style\n     * @param editorAction\n     * @param submitType\n     */\n    static forSecondary<Model>(editorAction: ActionEditorDescriptorInst<Model>, submitType = ActionEditorSubmitTypeEnum.Cancel): ActionEditorSubmitDescriptorInst<Model> {\n        return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(\n            new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton())\n        );\n    }\n}\n\nexport class ActionEditorDetailsDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {\n    public static readonly ACTION_NAME = 'details';\n\n    constructor(editorDescriptor: EditorDescriptorInst<Model>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>) {\n        super(editorDescriptor, ActionEditorDetailsDescriptorInst.ACTION_NAME, cfg);\n        this.withPosition(ActionPositionEnum.RowClick);\n        this.withRouteTrigger(':itemId');\n        this.withEditorActions([ActionEditorSubmitDescriptor.forSecondary(this, ActionEditorSubmitTypeEnum.Cancel)]);\n        this.withTableviewCategory(TableviewActionDefaultCategories.DETAILS);\n    }\n}\n\nexport class ActionEditorDetailsDescriptor {\n    public static create<Model>(editor: EditorDescriptorInst<Model>) {\n        return new ActionEditorDetailsDescriptorInst<Model, undefined>(editor);\n    }\n\n    public static createWithProvider<Model, Service>(editor: EditorDescriptorInst<Model>, serviceProvider: ActionEditorProviderType<Model, Service>) {\n        return new ActionEditorDetailsDescriptorInst<Model, Service>(editor, {\n            ...actionEditorGetProviderCfgObj(serviceProvider)\n        });\n    }\n}\n\nexport class ActionEditorAddDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {\n    public static readonly ACTION_NAME = 'add';\n\n    constructor(editorDescriptor: EditorDescriptorInst<Model>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>) {\n        super(editorDescriptor, ActionEditorAddDescriptorInst.ACTION_NAME, cfg);\n        this.withPosition(ActionPositionEnum.ToolbarLeft);\n        this.withRouteTrigger('add');\n        this.button.withIcon('pi pi-plus');\n        this.withTableviewCategory(TableviewActionDefaultCategories.ADD);\n        this.withUnsavedChangesConfirmation();\n    }\n}\n\nexport class ActionEditorAddDescriptor {\n    public static create<Model>(editor: EditorDescriptorInst<Model>) {\n        return new ActionEditorAddDescriptorInst<Model, undefined>(editor);\n    }\n\n    public static createWithProvider<Model, Service>(editor: EditorDescriptorInst<Model>, serviceProvider: ActionEditorProviderType<Model, Service>) {\n        return new ActionEditorAddDescriptorInst<Model, Service>(editor, {\n            ...actionEditorGetProviderCfgObj(serviceProvider)\n        });\n    }\n}\n\nexport class ActionEditorEditDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {\n    public static readonly ACTION_NAME = 'edit';\n\n    constructor(editorDescriptor: EditorDescriptorInst<Model>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>) {\n        super(editorDescriptor, ActionEditorEditDescriptorInst.ACTION_NAME, cfg);\n        this.withPosition(ActionPositionEnum.RowInline);\n        this.button.styleClass.withSize(StyleSizeEnum.Small);\n        this.withRouteTrigger(':itemId/edit');\n        this.withTableviewCategory(TableviewActionDefaultCategories.EDIT);\n        this.button.withLabel(null).withIcon('pi pi-pencil');\n        this.withUnsavedChangesConfirmation();\n    }\n}\n\nexport class ActionEditorEditDescriptor {\n    public static create<Model>(editor: EditorDescriptorInst<Model>) {\n        return new ActionEditorEditDescriptorInst<Model, undefined>(editor);\n    }\n\n    public static createWithProvider<Model, Service>(editor: EditorDescriptorInst<Model>, serviceProvider: ActionEditorProviderType<Model, Service>) {\n        return new ActionEditorEditDescriptorInst<Model, Service>(editor, {\n            ...actionEditorGetProviderCfgObj(serviceProvider)\n        });\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-editor.descriptor.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/action/descriptors/action-editor.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\n\nimport {Observable} from 'rxjs';\n\nimport {CommonsInternalError, ServiceClassType, StyleSizeEnum} from '@mediusinc/mng-commons/core';\nimport {ActionButtonDescriptor, ButtonStyleBuilder} from '@mediusinc/mng-commons/form/api';\nimport {ModelDescriptor} from '@mediusinc/mng-commons/model';\n\nimport {EditorDataProviderInst, IEditorDataProvider} from '../../editor/data-providers/editor.data-provider';\nimport {EditorDescriptorInst} from '../../editor/descriptors/editor.descriptor';\nimport {ActionEditorSubmitTypeEnum, ActionPositionEnum, ActionTypeEnum} from '../models/action.type';\nimport {IActionContext} from '../models/execution/action-context.model';\nimport {TableviewActionDefaultCategories} from '../models/tableview-action-default-categories.model';\nimport {ActionDescriptorCreateOptsParentType, ActionDescriptorInst} from './action.descriptor';\n\nexport type ActionEditorDescriptorConstructorOptsType<Model, Service> = ActionDescriptorCreateOptsParentType &\n    ActionEditorDescriptorCreateOptsProviderType<Model, Service> & {\n        model?: ModelDescriptor<Model>;\n    };\n\nexport type ActionEditorDescriptorCreateOptsProviderType<Model, Service> = {\n    serviceType?: ServiceClassType<Service>;\n    dataProvider?: IEditorDataProvider<Model, Service>;\n};\n\nexport class ActionEditorDescriptorInst<Item, Service = any> extends ActionDescriptorInst<Item, Service> {\n    private readonly _editorDescriptor: EditorDescriptorInst<Item, any>;\n    protected override readonly _dataProvider?: IEditorDataProvider<Item, any> = undefined;\n\n    protected _editorActions: ActionDescriptorInst<Item>[] = [];\n    protected _editorTitle?: string | null = undefined;\n    protected _editorTitleParams?: any = undefined;\n\n    protected _hasFetchNotificationSuccess = false;\n    protected _fetchNotificationSuccessTitle?: string;\n    protected _fetchNotificationSuccessMessage?: string;\n\n    protected _dialogSize = StyleSizeEnum.Normal;\n    protected _dialogClassName?: string;\n\n    protected _fetchFunction?: (ctx: IActionContext<Item, Service>) => Observable<Item>;\n    protected _submitFunction?: (ctx: IActionContext<Item, Service>) => Observable<Item>;\n\n    protected _editorComponent?: Type<any>;\n\n    protected _resubmitEnabled?: boolean;\n    protected _resubmitRefetch = true;\n    protected _unsavedChangesConfirmation = false;\n\n    public constructor(editorDescriptor: EditorDescriptorInst<Item, any>, actionName: string, cfg?: ActionEditorDescriptorConstructorOptsType<Item, Service>) {\n        super(actionName, {\n            model: editorDescriptor.model,\n            ...cfg\n        });\n\n        if (cfg?.serviceType) {\n            this._dataProvider = new EditorDataProviderInst<Item, Service>(this._model?.type, cfg.serviceType);\n        } else if (cfg?.dataProvider) {\n            this._dataProvider = cfg.dataProvider;\n        }\n\n        this._type = ActionTypeEnum.Editor;\n        this._editorDescriptor = editorDescriptor;\n        this._editorActions.push(actionEditorSubmit(this), actionEditorCancel(this));\n    }\n\n    public get editorTitle() {\n        return this._editorTitle;\n    }\n\n    public get editorTitleParams() {\n        return this._editorTitleParams;\n    }\n\n    public get editorDescriptor() {\n        return this._editorDescriptor;\n    }\n\n    public get dialogSize() {\n        return this._dialogSize;\n    }\n\n    public get dialogClassName() {\n        return this._dialogClassName;\n    }\n\n    public get hasFetchNotificationSuccess() {\n        return this._hasFetchNotificationSuccess;\n    }\n\n    public get fetchNotificationSuccessTitle() {\n        return this._fetchNotificationSuccessTitle;\n    }\n\n    public get fetchNotificationSuccessMessage() {\n        return this._fetchNotificationSuccessMessage;\n    }\n\n    public override get dataProvider() {\n        return this._dataProvider;\n    }\n\n    public override get hasRunFunction(): boolean {\n        throw new CommonsInternalError(`Run function cannot be used in editor action for ${this._actionNameLong}. Use submit function instead`);\n    }\n\n    public override get runFunction(): (ctx: IActionContext<Item, unknown>) => Observable<Item> {\n        throw new CommonsInternalError(`Run function cannot be used in editor action for ${this._actionNameLong}. Use submit function instead`);\n    }\n\n    public get hasFetchFunction(): boolean {\n        return typeof this._fetchFunction === 'function';\n    }\n\n    public get fetchFunction() {\n        return this._fetchFunction;\n    }\n\n    public get hasSubmitFunction(): boolean {\n        return typeof this._fetchFunction === 'function';\n    }\n\n    public get submitFunction() {\n        return this._submitFunction;\n    }\n\n    public get editorActions() {\n        return this._editorActions;\n    }\n\n    public get editorComponent() {\n        return this._editorComponent;\n    }\n\n    public get resubmitEnabled() {\n        return this._resubmitEnabled;\n    }\n\n    public get resubmitRefetch() {\n        return this._resubmitRefetch;\n    }\n\n    public get unsavedChangesConfirmation() {\n        return this._unsavedChangesConfirmation;\n    }\n\n    public withEditorTitle(title: string | null, params?: any): this {\n        this._editorTitle = title;\n        this._editorTitleParams = params;\n        return this;\n    }\n\n    public withDialogSize(size = StyleSizeEnum.Normal): this {\n        this._dialogSize = size;\n        return this;\n    }\n\n    public withDialogClassName(className: string): this {\n        this._dialogClassName = className;\n        return this;\n    }\n\n    public override withRunFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this {\n        return this.withSubmitFunction(fn as (ctx: IActionContext<Item, Service>) => Observable<Item>);\n    }\n\n    public withFetchFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this {\n        this._fetchFunction = fn;\n        return this;\n    }\n\n    public withSubmitFunction(fn: (ctx: IActionContext<Item, Service>) => Observable<Item>): this {\n        this._submitFunction = fn;\n        return this;\n    }\n\n    public withFetchNotificationError(title?: string, message?: string, hasNotification = true): this {\n        this._hasFetchNotificationSuccess = hasNotification;\n        this._fetchNotificationSuccessTitle = title;\n        this._fetchNotificationSuccessMessage = message;\n        return this;\n    }\n\n    public withEditorAction(action: ActionDescriptorInst<Item>): this {\n        this._editorActions.push(action);\n        return this;\n    }\n\n    public withEditorActions(actions: ActionDescriptorInst<Item>[]): this {\n        this._editorActions = actions;\n        return this;\n    }\n\n    public withEditorComponent(editorComponent: Type<any>): this {\n        this._editorComponent = editorComponent;\n        return this;\n    }\n\n    /**\n     * Enables or disables resubmit resubmit - this means the form will not exit after successful submission, but will instead remain open.\n     *\n     * @param {boolean} [enabled=true] - Specifies whether resubmit is enabled or disabled. Defaults to true if not provided.\n     * @param {boolean} [refetch=true] - Specifies whether the data should be refetched after resubmit. If not, the data in the form stays as is. Defaults to true if not provided.\n     *\n     * @returns {this} - Returns the current instance with the resubmit configuration updated.\n     */\n    public withResubmit(enabled?: boolean, refetch = true): this {\n        this._resubmitEnabled = enabled;\n        this._resubmitRefetch = refetch;\n        return this;\n    }\n\n    public withUnsavedChangesConfirmation(unsavedChangesConfirmation = true): this {\n        this._unsavedChangesConfirmation = unsavedChangesConfirmation;\n        return this;\n    }\n}\n\nexport class ActionEditorSubmitDescriptorInst<Model> extends ActionDescriptorInst<Model> {\n    private readonly _editorAction: ActionEditorDescriptorInst<Model>;\n    private readonly _submitType: ActionEditorSubmitTypeEnum;\n\n    public constructor(editorAction: ActionEditorDescriptorInst<Model>, submitType = ActionEditorSubmitTypeEnum.Submit) {\n        super(submitType === ActionEditorSubmitTypeEnum.Submit ? `${editorAction.actionName}.submit` : `${editorAction.actionName}.cancel`, {model: editorAction.model});\n        this._editorAction = editorAction;\n        this._submitType = submitType;\n        this._position = ActionPositionEnum.FooterRight;\n\n        this.button.styleClass.withActionLevel(editorAction.level).withTextButton();\n    }\n\n    public get submitType() {\n        return this._submitType;\n    }\n}\n\n/**\n * creates primary action with primary button style\n * @param editorAction\n * @param submitType\n */\nexport function actionEditorSubmit<Model>(\n    editorAction: ActionEditorDescriptorInst<Model>,\n    submitType = ActionEditorSubmitTypeEnum.Submit\n): ActionEditorSubmitDescriptorInst<Model> {\n    return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder()));\n}\n\n/**\n * creates secondary button with text button style\n * @param editorAction\n * @param submitType\n */\nexport function actionEditorCancel<Model>(\n    editorAction: ActionEditorDescriptorInst<Model>,\n    submitType = ActionEditorSubmitTypeEnum.Cancel\n): ActionEditorSubmitDescriptorInst<Model> {\n    return new ActionEditorSubmitDescriptorInst(editorAction, submitType).withButtonDescriptor(\n        new ActionButtonDescriptor().withStyleClass(new ButtonStyleBuilder().withTextButton())\n    );\n}\n\nexport class ActionEditorDetailsDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {\n    public static readonly ACTION_NAME = 'details';\n\n    constructor(editorDescriptor: EditorDescriptorInst<Model, any>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>) {\n        super(editorDescriptor, ActionEditorDetailsDescriptorInst.ACTION_NAME, cfg);\n        this.withPosition(ActionPositionEnum.RowClick);\n        this.withRouteTrigger(':itemId');\n        this.withEditorActions([actionEditorCancel(this)]);\n        this.withTableviewCategory(TableviewActionDefaultCategories.DETAILS);\n    }\n}\n\nexport class ActionEditorAddDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {\n    public static readonly ACTION_NAME = 'add';\n\n    constructor(editorDescriptor: EditorDescriptorInst<Model, any>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>) {\n        super(editorDescriptor, ActionEditorAddDescriptorInst.ACTION_NAME, cfg);\n        this.withPosition(ActionPositionEnum.ToolbarLeft);\n        this.withRouteTrigger('add');\n        this.button.withIcon('pi pi-plus');\n        this.withTableviewCategory(TableviewActionDefaultCategories.ADD);\n        this.withUnsavedChangesConfirmation();\n    }\n}\n\nexport class ActionEditorEditDescriptorInst<Model, Service = any> extends ActionEditorDescriptorInst<Model, Service> {\n    public static readonly ACTION_NAME = 'edit';\n\n    constructor(editorDescriptor: EditorDescriptorInst<Model, any>, cfg?: ActionEditorDescriptorCreateOptsProviderType<Model, Service>) {\n        super(editorDescriptor, ActionEditorEditDescriptorInst.ACTION_NAME, cfg);\n        this.withPosition(ActionPositionEnum.RowInline);\n        this.button.styleClass.withSize(StyleSizeEnum.Small);\n        this.withRouteTrigger(':itemId/edit');\n        this.withTableviewCategory(TableviewActionDefaultCategories.EDIT);\n        this.button.withLabel(null).withIcon('pi pi-pencil');\n        this.withUnsavedChangesConfirmation();\n    }\n}\n"]}