@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/esm2022/tableview/api/tableview/helpers/class-attribute-converter.mjs

@@ -0,0 +1,34 @@
+import { CommonsInternalError, TypeRegistry } from '@mediusinc/mng-commons/core';
+import { ColumnTypeEnum, getColumnDisplayTypeFromColumnType, getColumnTypeFromClassAttributeDefType } from '@mediusinc/mng-commons/table/api';
+import { getFieldInputTypeFromClassAttributeDefType } from '../../editor/helpers/class-attribute-converter';
+export function expandClassAttributeDefWithTableviewDef(attributes) {
+    if (!attributes) {
+        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
+    }
+    const typeRegistry = TypeRegistry.get();
+    const tableClassAttributeDef = [];
+    for (const attribute of attributes) {
+        const enumType = typeRegistry.findEnum(attribute.type);
+        const columnType = enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type);
+        tableClassAttributeDef.push({
+            name: attribute.name,
+            baseName: attribute.baseName,
+            type: attribute.type,
+            subtype: attribute.subtype,
+            columnType: enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type),
+            columnDisplayType: getColumnDisplayTypeFromColumnType(columnType, attribute.type),
+            fieldType: getFieldInputTypeFromClassAttributeDefType(attribute.type),
+            enumType: typeRegistry.findEnum(attribute.type),
+            classType: typeRegistry.findType(attribute.type)
+        });
+    }
+    return tableClassAttributeDef;
+}
+/**
+ * returns attributes from class type and extends to typed def with column and field enum type
+ * @param type class type
+ */
+export function getTableviewClassAttributeDef(type) {
+    return expandClassAttributeDefWithTableviewDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tableview/api/tableview/helpers/files-export.mjs

@@ -0,0 +1,34 @@
+import { GetterPipe } from '@mediusinc/mng-commons/core';
+export function convertDataToStringWithDelimiter(data, delimiter, descriptor, translate) {
+    const replaceNullValue = (key, value) => (value === null ? '' : value);
+    const getterPipe = new GetterPipe();
+    return [
+        descriptor.table.columns.map(col => translate.instant(descriptor.model.typeName + '.properties.' + col.property)).join(delimiter),
+        ...data.map((row) => descriptor.table.columns
+            .map(column => {
+            if (typeof column.getter === 'function') {
+                return JSON.stringify(getterPipe.transform(row[column.property], column.getter, row), replaceNullValue);
+            }
+            else {
+                return JSON.stringify(row[column.property], replaceNullValue);
+            }
+        })
+            .join(delimiter))
+    ].join('\r\n');
+}
+export function saveFileAs(blob, filename) {
+    const blobUrl = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.style.display = 'none';
+    link.target = '_blank';
+    link.href = blobUrl;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.dispatchEvent(new MouseEvent('click', {
+        bubbles: true,
+        cancelable: true,
+        view: window
+    }));
+    document.body.removeChild(link);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tableview/api/tableview/helpers/tableview-create.mjs

@@ -0,0 +1,24 @@
+import { Injector, inject } from '@angular/core';
+import { TableviewDataProvider } from '../data-providers/tableview.data-provider';
+import { TableviewDescriptor } from '../descriptors/tableview.descriptor';
+import { TableviewInputBuilder } from './tableview-input-builder';
+/**
+ * Creates a tableview with the given model, service.
+ *
+ * @param {ModelDescriptor<Model>} model - The model descriptor.
+ * @param {ServiceClassType<Service>} service - The class type of the service.
+ * @param {(builder: TableviewBuilder) => void} [buildFn] - The optional callback function to customize the tableview using the prepared builder.
+ *
+ * @returns A tableview instance with descriptor, data provider and actions.
+ */
+export function tableview(model, service, buildFn) {
+    const builder = new TableviewInputBuilder(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+export function tableviewWithSortAndFilter(model, service, sorts, filters, buildFn) {
+    const builder = new TableviewInputBuilder(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tableview/api/tableview/helpers/tableview-default-actions.mjs

@@ -0,0 +1,240 @@
+import { Injector, inject } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { of, tap } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { CommonsInternalError, DataListParamsUtil, StyleLevelEnum, StyleSizeEnum } from '@mediusinc/mng-commons/core';
+import { ActionButtonDescriptor, ButtonStyleRoundedEnum } from '@mediusinc/mng-commons/form/api';
+import { ActionEditorAddDescriptor, ActionEditorDetailsDescriptor, ActionEditorEditDescriptor, ActionEditorEditDescriptorInst } from '../../action/descriptors/action-editor.descriptor';
+import { ActionLinkDescriptor } from '../../action/descriptors/action-link.descriptor';
+import { ActionDeleteDescriptor, ActionDescriptor } from '../../action/descriptors/action.descriptor';
+import { ActionPositionEnum } from '../../action/models/action.type';
+import { TableviewActionDefaultCategories } from '../../action/models/tableview-action-default-categories.model';
+import { DataProviderExecutor } from '../../action/services/data-provider-executor.service';
+import { DATA_LANGUAGE_DROPDOWN_COMPONENT_IT } from '../../action/services/tokens/data-language-dropdown.token';
+import { convertDataToStringWithDelimiter, saveFileAs } from './files-export';
+export var TableviewDefaultActionsEnum;
+(function (TableviewDefaultActionsEnum) {
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Details"] = 0] = "Details";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Add"] = 1] = "Add";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Edit"] = 2] = "Edit";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["EditOnDetails"] = 3] = "EditOnDetails";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Delete"] = 4] = "Delete";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["DeleteOnDetails"] = 5] = "DeleteOnDetails";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Refresh"] = 6] = "Refresh";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["Export"] = 7] = "Export";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["ExportJson"] = 8] = "ExportJson";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["ExportCsv"] = 9] = "ExportCsv";
+    TableviewDefaultActionsEnum[TableviewDefaultActionsEnum["LocalizationLanguageSelect"] = 10] = "LocalizationLanguageSelect";
+})(TableviewDefaultActionsEnum || (TableviewDefaultActionsEnum = {}));
+const tableviewDefaultActions = [
+    TableviewDefaultActionsEnum.Details,
+    TableviewDefaultActionsEnum.Add,
+    TableviewDefaultActionsEnum.Edit,
+    TableviewDefaultActionsEnum.EditOnDetails,
+    TableviewDefaultActionsEnum.Delete,
+    TableviewDefaultActionsEnum.DeleteOnDetails,
+    TableviewDefaultActionsEnum.Refresh,
+    TableviewDefaultActionsEnum.Export,
+    TableviewDefaultActionsEnum.ExportJson,
+    TableviewDefaultActionsEnum.ExportCsv,
+    TableviewDefaultActionsEnum.LocalizationLanguageSelect
+];
+export function getTableviewDefaultActions() {
+    return [...tableviewDefaultActions];
+}
+export function createTableviewActions(tableview, defaultActions, defaultActionsOverrides, injector) {
+    return (defaultActions ?? getTableviewDefaultActions())
+        .map(t => createTableviewAction(t, tableview, defaultActions, defaultActionsOverrides, injector))
+        .filter(e => e != null);
+}
+export function createTableviewAction(type, tableview, defaultActions, defaultActionsOverrides, injector) {
+    if (defaultActionsOverrides != null && defaultActionsOverrides[type] !== undefined) {
+        return defaultActionsOverrides[type];
+    }
+    switch (type) {
+        // table row actions
+        case TableviewDefaultActionsEnum.Details:
+            return tableviewDetailsAction(tableview.detailsEditor, injector);
+        case TableviewDefaultActionsEnum.Edit:
+            return tableviewEditAction(tableview.editEditor, injector);
+        case TableviewDefaultActionsEnum.Delete:
+            return tableviewDeleteAction(tableview.model, injector);
+        // table toolbar actions
+        case TableviewDefaultActionsEnum.Add:
+            return tableviewAddAction(tableview.addEditor, injector);
+        case TableviewDefaultActionsEnum.LocalizationLanguageSelect:
+            return tableviewLocalizationLanguageSelectAction(tableview);
+        case TableviewDefaultActionsEnum.Refresh:
+            return tableviewRefreshAction(tableview.model);
+        case TableviewDefaultActionsEnum.Export:
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson) || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)
+                ? tableviewExportAction(tableview, injector, defaultActions)
+                : null;
+        //details actions
+        case TableviewDefaultActionsEnum.EditOnDetails:
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Edit)
+                ? tableviewEditOnDetailsAction(tableview.model, tableviewEditAction(tableview.editEditor, injector), injector)
+                : null;
+        case TableviewDefaultActionsEnum.DeleteOnDetails:
+            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Delete) ? tableviewDeleteOnDetailsAction(tableview.model, injector) : null;
+        // subactions
+        case TableviewDefaultActionsEnum.ExportJson:
+        case TableviewDefaultActionsEnum.ExportCsv:
+            return null;
+        default:
+            throw new CommonsInternalError(`Tableview default action of type ${type} not supported`);
+    }
+}
+function getInjector(injector) {
+    return injector === undefined ? inject(Injector) : injector;
+}
+function getRouteData(injector) {
+    return getInjector(injector)?.get(ActivatedRoute)?.snapshot.data;
+}
+export function tableviewDetailsAction(descriptor, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.create(descriptor) : null;
+}
+export function tableviewDetailsActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+export function tableviewAddAction(descriptor, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.create(descriptor) : null;
+}
+export function tableviewAddActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+export function tableviewEditAction(descriptor, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.create(descriptor) : null;
+}
+export function tableviewEditActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+export function tableviewEditOnDetailsAction(descriptor, editDescriptor, injector) {
+    const routeData = getRouteData(injector);
+    if (routeData?.tableviewActions && !routeData.tableviewActions.hasEdit) {
+        return null;
+    }
+    const action = editDescriptor ? ActionLinkDescriptor.fromAction(editDescriptor) : ActionLinkDescriptor.fromModel(descriptor, ActionEditorEditDescriptorInst.ACTION_NAME);
+    action
+        .withTableviewCategory(TableviewActionDefaultCategories.EDIT)
+        .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])
+        .withPosition(ActionPositionEnum.FooterLeft)
+        .withRouterLink('./edit');
+    action.button.styleClass.withActionLevel(StyleLevelEnum.Secondary);
+    action.button.styleClass.withSize(StyleSizeEnum.Normal);
+    action.button.styleClass.withRoundedButton(ButtonStyleRoundedEnum.DEFAULT);
+    action.button.withLabel();
+    if (!editDescriptor)
+        action.button.withIcon('pi pi-pencil');
+    return action;
+}
+export function tableviewDeleteAction(descriptor, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? ActionDeleteDescriptor.create(descriptor) : null;
+}
+export function tableviewDeleteActionWithProvider(descriptor, serviceProvider, injector) {
+    const routeData = getRouteData(injector);
+    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? ActionDeleteDescriptor.createWithProvider(descriptor, serviceProvider) : null;
+}
+export function tableviewDeleteOnDetailsAction(model, injector) {
+    const action = tableviewDeleteAction(model, injector);
+    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+    if (action) {
+        action
+            .withTableviewCategory(TableviewActionDefaultCategories.DELETE)
+            .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])
+            .withPosition(ActionPositionEnum.FooterLeft)
+            .withRunFunction(ctx => dataProviderExecutor
+            ? dataProviderExecutor.runDeleteOrFail(ctx).pipe(tap(() => {
+                ctx.viewContainer?.reloadTable({});
+                ctx.viewContainer?.closeEditor();
+            }))
+            : null);
+        action.button.withLabel(undefined);
+        action.button.styleClass.withSize(StyleSizeEnum.Normal);
+        return action;
+    }
+    return null;
+}
+export function tableviewExportAction(descriptor, injector, defaultActions) {
+    const exportAction = ActionDescriptor.fromModel(descriptor.model, 'export')
+        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-download'))
+        .withSubactionsAsMenu();
+    const subactions = [];
+    if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson))
+        subactions.push(tableviewExportJsonAction(descriptor, injector));
+    if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv))
+        subactions.push(tableviewExportCsvAction(descriptor, injector));
+    exportAction.withSubactions(...subactions);
+    return exportAction;
+}
+export function tableviewExportJsonAction(descriptor, injector) {
+    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+    return ActionDescriptor.fromModel(descriptor.model, 'exportJson')
+        .withRunFunction(ctx => {
+        const params = ctx.parameters.dataListParams ? DataListParamsUtil.copy(ctx.parameters.dataListParams) : {};
+        params.offset = 0;
+        params.limit = 500;
+        ctx.parameters.dataListParams = params;
+        return dataProviderExecutor
+            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map(res => {
+                const blob = new Blob([JSON.stringify(res.data, undefined, 4)], { type: 'application/json;charset=utf-8' });
+                const typeName = ctx.instance.action.model?.typeName ?? '';
+                saveFileAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.json`);
+                return undefined;
+            }))
+            : ctx.parameters.item;
+    })
+        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-code'))
+        .withPosition(ActionPositionEnum.ToolbarRight);
+}
+export function tableviewExportCsvAction(descriptor, injector) {
+    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);
+    return ActionDescriptor.fromModel(descriptor.model, 'exportCsv')
+        .withRunFunction(ctx => {
+        const params = ctx.parameters.dataListParams ? DataListParamsUtil.copy(ctx.parameters.dataListParams) : {};
+        params.offset = 0;
+        params.limit = 500;
+        ctx.parameters.dataListParams = params;
+        return dataProviderExecutor
+            ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(map(res => {
+                if (!res.data) {
+                    return undefined;
+                }
+                const blob = new Blob([convertDataToStringWithDelimiter(res.data, ',', descriptor, ctx.injector.get(TranslateService))], {
+                    type: 'text/csv;charset=utf-8'
+                });
+                const typeName = ctx.instance.action.model?.typeName ?? '';
+                saveFileAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.csv`);
+                return undefined;
+            }))
+            : ctx.parameters.item;
+    })
+        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-file'))
+        .withPosition(ActionPositionEnum.ToolbarRight);
+}
+export function tableviewRefreshAction(descriptor) {
+    const action = ActionDescriptor.fromModel(descriptor, 'refresh')
+        .withPosition(ActionPositionEnum.ToolbarRight)
+        .withTableviewCategory(TableviewActionDefaultCategories.READ)
+        .withRunNotificationSuccess(undefined, undefined, false)
+        .withRunFunction(ctx => {
+        ctx.viewContainer?.reloadTable({});
+        return of(null);
+    });
+    action.button.withIcon('pi pi-refresh').styleClass.withActionLevel(StyleLevelEnum.Secondary);
+    return action;
+}
+export function tableviewLocalizationLanguageSelectAction(descriptor) {
+    return descriptor.isLocalized()
+        ? ActionDescriptor.fromModel(descriptor.model, 'translator').withPosition(ActionPositionEnum.ToolbarLeft).withComponentFromDi(DATA_LANGUAGE_DROPDOWN_COMPONENT_IT)
+        : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-default-actions.js","sourceRoot":"","sources":["../../../../../../tableview/api/src/tableview/helpers/tableview-default-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injector, inject} from '@angular/core';\nimport {ActivatedRoute} from '@angular/router';\n\nimport {TranslateService} from '@ngx-translate/core';\nimport {of, tap} from 'rxjs';\nimport {map} from 'rxjs/operators';\n\nimport {CommonsInternalError, DataListParamsUtil, StyleLevelEnum, StyleSizeEnum} from '@mediusinc/mng-commons/core';\nimport {ActionButtonDescriptor, ButtonStyleRoundedEnum} from '@mediusinc/mng-commons/form/api';\nimport {ModelDescriptor} from '@mediusinc/mng-commons/model';\n\nimport {\n    ActionEditorAddDescriptor,\n    ActionEditorAddDescriptorInst,\n    ActionEditorDetailsDescriptor,\n    ActionEditorDetailsDescriptorInst,\n    ActionEditorEditDescriptor,\n    ActionEditorEditDescriptorInst,\n    ActionEditorProviderType\n} from '../../action/descriptors/action-editor.descriptor';\nimport {ActionLinkDescriptor, ActionLinkDescriptorInst} from '../../action/descriptors/action-link.descriptor';\nimport {ActionDeleteDescriptor, ActionDeleteDescriptorInst, ActionDescriptor, ActionDescriptorInst, ActionProviderType} from '../../action/descriptors/action.descriptor';\nimport {ActionPositionEnum} from '../../action/models/action.type';\nimport {TableviewActionDefaultCategories} from '../../action/models/tableview-action-default-categories.model';\nimport {DataProviderExecutor} from '../../action/services/data-provider-executor.service';\nimport {DATA_LANGUAGE_DROPDOWN_COMPONENT_IT} from '../../action/services/tokens/data-language-dropdown.token';\nimport {EditorDescriptorInst} from '../../editor/descriptors/editor.descriptor';\nimport {TableviewDescriptorInst} from '../descriptors/tableview.descriptor';\nimport {TableviewRouteData} from '../models/tableview-route.model';\nimport {convertDataToStringWithDelimiter, saveFileAs} from './files-export';\n\nexport enum TableviewDefaultActionsEnum {\n    Details,\n    Add,\n    Edit,\n    EditOnDetails,\n    Delete,\n    DeleteOnDetails,\n    Refresh,\n    Export,\n    ExportJson,\n    ExportCsv,\n    LocalizationLanguageSelect\n}\n\nconst tableviewDefaultActions = [\n    TableviewDefaultActionsEnum.Details,\n    TableviewDefaultActionsEnum.Add,\n    TableviewDefaultActionsEnum.Edit,\n    TableviewDefaultActionsEnum.EditOnDetails,\n    TableviewDefaultActionsEnum.Delete,\n    TableviewDefaultActionsEnum.DeleteOnDetails,\n    TableviewDefaultActionsEnum.Refresh,\n    TableviewDefaultActionsEnum.Export,\n    TableviewDefaultActionsEnum.ExportJson,\n    TableviewDefaultActionsEnum.ExportCsv,\n    TableviewDefaultActionsEnum.LocalizationLanguageSelect\n];\n\nexport function getTableviewDefaultActions() {\n    return [...tableviewDefaultActions];\n}\n\nexport function createTableviewActions(\n    tableview: TableviewDescriptorInst<any, any, any>,\n    defaultActions?: TableviewDefaultActionsEnum[],\n    defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>,\n    injector?: Injector | null\n): Array<ActionDescriptorInst<any>> {\n    return (defaultActions ?? getTableviewDefaultActions())\n        .map(t => createTableviewAction(t, tableview, defaultActions, defaultActionsOverrides, injector))\n        .filter(e => e != null) as Array<ActionDescriptorInst<any>>;\n}\n\nexport function createTableviewAction(\n    type: TableviewDefaultActionsEnum,\n    tableview: TableviewDescriptorInst<any, any, any>,\n    defaultActions?: TableviewDefaultActionsEnum[],\n    defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>,\n    injector?: Injector | null\n): ActionDescriptorInst<any> | null {\n    if (defaultActionsOverrides != null && defaultActionsOverrides[type] !== undefined) {\n        return defaultActionsOverrides[type];\n    }\n\n    switch (type) {\n        // table row actions\n        case TableviewDefaultActionsEnum.Details:\n            return tableviewDetailsAction(tableview.detailsEditor, injector);\n        case TableviewDefaultActionsEnum.Edit:\n            return tableviewEditAction(tableview.editEditor, injector);\n        case TableviewDefaultActionsEnum.Delete:\n            return tableviewDeleteAction(tableview.model, injector);\n        // table toolbar actions\n        case TableviewDefaultActionsEnum.Add:\n            return tableviewAddAction(tableview.addEditor, injector);\n        case TableviewDefaultActionsEnum.LocalizationLanguageSelect:\n            return tableviewLocalizationLanguageSelectAction(tableview);\n        case TableviewDefaultActionsEnum.Refresh:\n            return tableviewRefreshAction(tableview.model);\n        case TableviewDefaultActionsEnum.Export:\n            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson) || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)\n                ? tableviewExportAction(tableview, injector, defaultActions)\n                : null;\n        //details actions\n        case TableviewDefaultActionsEnum.EditOnDetails:\n            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Edit)\n                ? tableviewEditOnDetailsAction(tableview.model, tableviewEditAction(tableview.editEditor, injector), injector)\n                : null;\n        case TableviewDefaultActionsEnum.DeleteOnDetails:\n            return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Delete) ? tableviewDeleteOnDetailsAction(tableview.model, injector) : null;\n        // subactions\n        case TableviewDefaultActionsEnum.ExportJson:\n        case TableviewDefaultActionsEnum.ExportCsv:\n            return null;\n        default:\n            throw new CommonsInternalError(`Tableview default action of type ${type} not supported`);\n    }\n}\n\nfunction getInjector(injector?: Injector | null): Injector | null {\n    return injector === undefined ? inject(Injector) : injector;\n}\n\nfunction getRouteData(injector?: Injector | null) {\n    return getInjector(injector)?.get(ActivatedRoute)?.snapshot.data as TableviewRouteData | undefined;\n}\n\nexport function tableviewDetailsAction<Model>(descriptor: EditorDescriptorInst<Model>, injector?: Injector | null): ActionEditorDetailsDescriptorInst<Model> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.create(descriptor) : null;\n}\n\nexport function tableviewDetailsActionWithProvider<Model, Service>(\n    descriptor: EditorDescriptorInst<Model>,\n    serviceProvider: ActionEditorProviderType<Model, Service>,\n    injector?: Injector | null\n): ActionEditorDetailsDescriptorInst<Model, Service> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.createWithProvider(descriptor, serviceProvider) : null;\n}\n\nexport function tableviewAddAction<Model>(descriptor: EditorDescriptorInst<Model>, injector?: Injector | null): ActionEditorAddDescriptorInst<Model> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.create(descriptor) : null;\n}\n\nexport function tableviewAddActionWithProvider<Model, Service>(\n    descriptor: EditorDescriptorInst<Model>,\n    serviceProvider: ActionEditorProviderType<Model, Service>,\n    injector?: Injector | null\n): ActionEditorAddDescriptorInst<Model, Service> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.createWithProvider(descriptor, serviceProvider) : null;\n}\n\nexport function tableviewEditAction<Model>(descriptor: EditorDescriptorInst<Model>, injector?: Injector | null): ActionEditorEditDescriptorInst<Model> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.create(descriptor) : null;\n}\n\nexport function tableviewEditActionWithProvider<Model, Service>(\n    descriptor: EditorDescriptorInst<Model>,\n    serviceProvider: ActionEditorProviderType<Model, Service>,\n    injector?: Injector | null\n): ActionEditorEditDescriptorInst<Model, Service> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.createWithProvider(descriptor, serviceProvider) : null;\n}\n\nexport function tableviewEditOnDetailsAction<Model>(\n    descriptor: ModelDescriptor<Model>,\n    editDescriptor: ActionEditorEditDescriptorInst<Model> | null,\n    injector?: Injector | null\n): ActionLinkDescriptorInst<Model> | null {\n    const routeData = getRouteData(injector);\n    if (routeData?.tableviewActions && !routeData.tableviewActions.hasEdit) {\n        return null;\n    }\n\n    const action = editDescriptor ? ActionLinkDescriptor.fromAction(editDescriptor) : ActionLinkDescriptor.fromModel(descriptor, ActionEditorEditDescriptorInst.ACTION_NAME);\n    action\n        .withTableviewCategory(TableviewActionDefaultCategories.EDIT)\n        .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])\n        .withPosition(ActionPositionEnum.FooterLeft)\n        .withRouterLink('./edit');\n    action.button.styleClass.withActionLevel(StyleLevelEnum.Secondary);\n    action.button.styleClass.withSize(StyleSizeEnum.Normal);\n    action.button.styleClass.withRoundedButton(ButtonStyleRoundedEnum.DEFAULT);\n    action.button.withLabel();\n    if (!editDescriptor) action.button.withIcon('pi pi-pencil');\n\n    return action;\n}\n\nexport function tableviewDeleteAction<Model>(descriptor: ModelDescriptor<Model>, injector?: Injector | null): ActionDeleteDescriptorInst<Model> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? ActionDeleteDescriptor.create(descriptor) : null;\n}\n\nexport function tableviewDeleteActionWithProvider<Model, Service>(\n    descriptor: ModelDescriptor<Model>,\n    serviceProvider: ActionProviderType<Model, Service>,\n    injector?: Injector | null\n): ActionDeleteDescriptorInst<Model, Service> | null {\n    const routeData = getRouteData(injector);\n    return !routeData?.tableviewActions || routeData.tableviewActions.hasDelete ? ActionDeleteDescriptor.createWithProvider(descriptor, serviceProvider) : null;\n}\n\nexport function tableviewDeleteOnDetailsAction<Model>(model: ModelDescriptor<Model>, injector?: Injector | null): ActionDescriptorInst<Model> | null {\n    const action = tableviewDeleteAction(model, injector);\n    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);\n    if (action) {\n        action\n            .withTableviewCategory(TableviewActionDefaultCategories.DELETE)\n            .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])\n            .withPosition(ActionPositionEnum.FooterLeft)\n            .withRunFunction(ctx =>\n                dataProviderExecutor\n                    ? dataProviderExecutor.runDeleteOrFail(ctx).pipe(\n                          tap(() => {\n                              ctx.viewContainer?.reloadTable({});\n                              ctx.viewContainer?.closeEditor();\n                          })\n                      )\n                    : null\n            );\n        action.button.withLabel(undefined);\n        action.button.styleClass.withSize(StyleSizeEnum.Normal);\n\n        return action;\n    }\n\n    return null;\n}\n\nexport function tableviewExportAction<Model>(\n    descriptor: TableviewDescriptorInst<Model>,\n    injector?: Injector | null,\n    defaultActions?: TableviewDefaultActionsEnum[]\n): ActionDescriptorInst<Model> | null {\n    const exportAction = ActionDescriptor.fromModel(descriptor.model, 'export')\n        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-download'))\n        .withSubactionsAsMenu();\n\n    const subactions: ActionDescriptorInst<Model>[] = [];\n\n    if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson)) subactions.push(tableviewExportJsonAction(descriptor, injector));\n    if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)) subactions.push(tableviewExportCsvAction(descriptor, injector));\n\n    exportAction.withSubactions(...subactions);\n    return exportAction;\n}\n\nexport function tableviewExportJsonAction<Model>(descriptor: TableviewDescriptorInst<Model>, injector?: Injector | null): ActionDescriptorInst<Model> {\n    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);\n    return ActionDescriptor.fromModel(descriptor.model, 'exportJson')\n        .withRunFunction(ctx => {\n            const params = ctx.parameters.dataListParams ? DataListParamsUtil.copy(ctx.parameters.dataListParams) : {};\n            params.offset = 0;\n            params.limit = 500;\n            ctx.parameters.dataListParams = params;\n            return dataProviderExecutor\n                ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(\n                      map(res => {\n                          const blob = new Blob([JSON.stringify(res.data, undefined, 4)], {type: 'application/json;charset=utf-8'});\n                          const typeName = ctx.instance.action.model?.typeName ?? '';\n                          saveFileAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.json`);\n                          return undefined;\n                      })\n                  )\n                : ctx.parameters.item;\n        })\n        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-code'))\n        .withPosition(ActionPositionEnum.ToolbarRight);\n}\n\nexport function tableviewExportCsvAction<Model>(descriptor: TableviewDescriptorInst<Model>, injector?: Injector | null): ActionDescriptorInst<Model> {\n    const dataProviderExecutor = getInjector(injector)?.get(DataProviderExecutor);\n    return ActionDescriptor.fromModel(descriptor.model, 'exportCsv')\n        .withRunFunction(ctx => {\n            const params = ctx.parameters.dataListParams ? DataListParamsUtil.copy(ctx.parameters.dataListParams) : {};\n            params.offset = 0;\n            params.limit = 500;\n            ctx.parameters.dataListParams = params;\n            return dataProviderExecutor\n                ? dataProviderExecutor.runGetAllOrFail(ctx).pipe(\n                      map(res => {\n                          if (!res.data) {\n                              return undefined;\n                          }\n                          const blob = new Blob([convertDataToStringWithDelimiter(res.data, ',', descriptor, ctx.injector.get(TranslateService))], {\n                              type: 'text/csv;charset=utf-8'\n                          });\n                          const typeName = ctx.instance.action.model?.typeName ?? '';\n                          saveFileAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.csv`);\n                          return undefined;\n                      })\n                  )\n                : ctx.parameters.item;\n        })\n        .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-file'))\n        .withPosition(ActionPositionEnum.ToolbarRight);\n}\n\nexport function tableviewRefreshAction<Model>(descriptor: ModelDescriptor<Model>): ActionDescriptorInst<Model> | null {\n    const action = ActionDescriptor.fromModel(descriptor, 'refresh')\n        .withPosition(ActionPositionEnum.ToolbarRight)\n        .withTableviewCategory(TableviewActionDefaultCategories.READ)\n        .withRunNotificationSuccess(undefined, undefined, false)\n        .withRunFunction(ctx => {\n            ctx.viewContainer?.reloadTable({});\n            return of(null);\n        });\n    action.button.withIcon('pi pi-refresh').styleClass.withActionLevel(StyleLevelEnum.Secondary);\n    return action;\n}\n\nexport function tableviewLocalizationLanguageSelectAction<Model>(descriptor: TableviewDescriptorInst<Model>): ActionDescriptorInst<Model> | null {\n    return descriptor.isLocalized()\n        ? ActionDescriptor.fromModel(descriptor.model, 'translator').withPosition(ActionPositionEnum.ToolbarLeft).withComponentFromDi(DATA_LANGUAGE_DROPDOWN_COMPONENT_IT)\n        : null;\n}\n"]}