@mediusinc/mng-commons 4.1.0 → 5.0.0-rc.0-c31d5206

package/esm2022/lib/components/tableview/actions/tableview-default-actions.mjs

@@ -0,0 +1,215 @@
+import { ActivatedRoute } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { of, tap } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ActionButtonDescriptor, ActionDeleteDescriptorInst, ActionDescriptor, ActionEditorAddDescriptor, ActionEditorDetailsDescriptor, ActionEditorEditDescriptor, ActionEditorEditDescriptorInst, ActionLinkDescriptor } from '../../../descriptors/action';
+import { ActionPositionEnum } from '../../../descriptors/types';
+import { MngInternalError } from '../../../models';
+import { DataProviderExecutor } from '../../../services';
+import { ButtonStyleRoundedEnum } from '../../../styles';
+import { StyleLevelEnum, StyleSizeEnum } from '../../../styles/models';
+import { DataListParamsUtil, ExportUtils, FileUtil } from '../../../utils';
+import { MngDataLanguageDropdownComponent } from '../../action';
+import { TableviewActionDefaultCategories } from '../../action/models';
+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 = {}));
+export class TableviewDefaultActions {
+    static { this.DEFAULT_ACTIONS = [
+        TableviewDefaultActionsEnum.Details,
+        TableviewDefaultActionsEnum.Add,
+        TableviewDefaultActionsEnum.Edit,
+        TableviewDefaultActionsEnum.EditOnDetails,
+        TableviewDefaultActionsEnum.Delete,
+        TableviewDefaultActionsEnum.DeleteOnDetails,
+        TableviewDefaultActionsEnum.Refresh,
+        TableviewDefaultActionsEnum.Export,
+        TableviewDefaultActionsEnum.ExportJson,
+        TableviewDefaultActionsEnum.ExportCsv,
+        TableviewDefaultActionsEnum.LocalizationLanguageSelect
+    ]; }
+    static getDefaultActions() {
+        return [...TableviewDefaultActions.DEFAULT_ACTIONS];
+    }
+    static createActions(tableview, injector, defaultActions, defaultActionsOverrides) {
+        return (defaultActions ?? TableviewDefaultActions.getDefaultActions())
+            .map(t => TableviewDefaultActions.createAction(t, tableview, injector, defaultActions, defaultActionsOverrides))
+            .filter(e => e != null);
+    }
+    static createAction(type, tableview, injector, defaultActions, defaultActionsOverrides) {
+        if (defaultActionsOverrides != null && defaultActionsOverrides[type] !== undefined) {
+            return defaultActionsOverrides[type];
+        }
+        switch (type) {
+            // table row actions
+            case TableviewDefaultActionsEnum.Details:
+                return TableviewDefaultActions.details(tableview.detailsEditor, injector);
+            case TableviewDefaultActionsEnum.Edit:
+                return TableviewDefaultActions.edit(tableview.editEditor, injector);
+            case TableviewDefaultActionsEnum.Delete:
+                return TableviewDefaultActions.delete(tableview.model, injector);
+            // table toolbar actions
+            case TableviewDefaultActionsEnum.Add:
+                return TableviewDefaultActions.add(tableview.addEditor, injector);
+            case TableviewDefaultActionsEnum.LocalizationLanguageSelect:
+                return TableviewDefaultActions.LocalizationLanguageSelect(tableview);
+            case TableviewDefaultActionsEnum.Refresh:
+                return TableviewDefaultActions.refresh(tableview.model);
+            case TableviewDefaultActionsEnum.Export:
+                return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson) || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)
+                    ? TableviewDefaultActions.export(tableview, injector, defaultActions)
+                    : null;
+            //details actions
+            case TableviewDefaultActionsEnum.EditOnDetails:
+                return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Edit)
+                    ? TableviewDefaultActions.editOnDetails(tableview.model, TableviewDefaultActions.edit(tableview.editEditor, injector), injector)
+                    : null;
+            case TableviewDefaultActionsEnum.DeleteOnDetails:
+                return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Delete)
+                    ? TableviewDefaultActions.deleteOnDetails(tableview.model, injector)
+                    : null;
+            // subactions
+            case TableviewDefaultActionsEnum.ExportJson:
+            case TableviewDefaultActionsEnum.ExportCsv:
+                return null;
+            default:
+                throw new MngInternalError(`Tableview default action of type ${type} not supported`);
+        }
+    }
+    static getRouteData(injector) {
+        return injector.get(ActivatedRoute).snapshot.data;
+    }
+    static details(descriptor, injector) {
+        const routeData = TableviewDefaultActions.getRouteData(injector);
+        return !routeData.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.create(descriptor) : null;
+    }
+    static add(descriptor, injector) {
+        const routeData = TableviewDefaultActions.getRouteData(injector);
+        return !routeData.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.create(descriptor) : null;
+    }
+    static edit(descriptor, injector) {
+        const routeData = TableviewDefaultActions.getRouteData(injector);
+        return !routeData.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.create(descriptor) : null;
+    }
+    static editOnDetails(descriptor, editDescriptor, injector) {
+        const routeData = TableviewDefaultActions.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;
+    }
+    static deleteOnDetails(model, injector) {
+        const action = this.delete(model, injector);
+        const dataProviderExecutor = injector.get(DataProviderExecutor);
+        if (action) {
+            action
+                .withTableviewCategory(TableviewActionDefaultCategories.DELETE)
+                .withPositionTableviewCategories([TableviewActionDefaultCategories.DETAILS])
+                .withPosition(ActionPositionEnum.FooterLeft)
+                .withRunFunction(ctx => dataProviderExecutor.runDeleteOrFail(ctx).pipe(tap(() => {
+                ctx.viewContainer?.reloadTable({});
+                ctx.viewContainer?.closeEditor();
+            })));
+            action.button.withLabel(undefined);
+            action.button.styleClass.withSize(StyleSizeEnum.Normal);
+            return action;
+        }
+        return null;
+    }
+    static delete(descriptor, injector) {
+        const routeData = TableviewDefaultActions.getRouteData(injector);
+        return !routeData.tableviewActions || routeData.tableviewActions.hasDelete ? new ActionDeleteDescriptorInst(descriptor) : null;
+    }
+    static export(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(this.exportJson(descriptor, injector));
+        if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv))
+            subactions.push(this.exportCsv(descriptor, injector));
+        exportAction.withSubactions(...subactions);
+        return exportAction;
+    }
+    static exportJson(descriptor, injector) {
+        const dataProviderExecutor = 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.withDataListParams(params);
+            return 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 ?? '';
+                FileUtil.saveAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.json`);
+                return undefined;
+            }));
+        })
+            .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-code'))
+            .withPosition(ActionPositionEnum.ToolbarRight);
+    }
+    static exportCsv(descriptor, injector) {
+        const dataProviderExecutor = 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.withDataListParams(params);
+            return dataProviderExecutor.runGetAllOrFail(ctx).pipe(map(res => {
+                if (!res.data) {
+                    return undefined;
+                }
+                const blob = new Blob([ExportUtils.prepareDataForExport(res.data, ',', descriptor, ctx.injector.get(TranslateService))], { type: 'text/csv;charset=utf-8' });
+                const typeName = ctx.instance.action.model?.typeName ?? '';
+                FileUtil.saveAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.csv`);
+                return undefined;
+            }));
+        })
+            .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-file'))
+            .withPosition(ActionPositionEnum.ToolbarRight);
+    }
+    static refresh(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;
+    }
+    static LocalizationLanguageSelect(descriptor) {
+        return descriptor.isLocalized()
+            ? ActionDescriptor.fromModel(descriptor.model, 'translator').withPosition(ActionPositionEnum.ToolbarLeft).withComponent(MngDataLanguageDropdownComponent)
+            : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-default-actions.js","sourceRoot":"","sources":["../../../../../../src/lib/components/tableview/actions/tableview-default-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injector} 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 {\n    ActionButtonDescriptor,\n    ActionDeleteDescriptorInst,\n    ActionDescriptor,\n    ActionDescriptorInst,\n    ActionEditorAddDescriptor,\n    ActionEditorAddDescriptorInst,\n    ActionEditorDetailsDescriptor,\n    ActionEditorDetailsDescriptorInst,\n    ActionEditorEditDescriptor,\n    ActionEditorEditDescriptorInst,\n    ActionLinkDescriptor,\n    ActionLinkDescriptorInst\n} from '../../../descriptors/action';\nimport {EditorDescriptorInst} from '../../../descriptors/editor';\nimport {ModelDescriptor} from '../../../descriptors/model';\nimport {TableviewDescriptorInst} from '../../../descriptors/tableview';\nimport {ActionPositionEnum} from '../../../descriptors/types';\nimport {MngInternalError} from '../../../models';\nimport {MngRouterData} from '../../../router/models';\nimport {DataProviderExecutor} from '../../../services';\nimport {ButtonStyleRoundedEnum} from '../../../styles';\nimport {StyleLevelEnum, StyleSizeEnum} from '../../../styles/models';\nimport {DataListParamsUtil, ExportUtils, FileUtil} from '../../../utils';\nimport {MngDataLanguageDropdownComponent} from '../../action';\nimport {TableviewActionDefaultCategories} from '../../action/models';\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\nexport class TableviewDefaultActions {\n    private static readonly DEFAULT_ACTIONS = [\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\n    public static getDefaultActions() {\n        return [...TableviewDefaultActions.DEFAULT_ACTIONS];\n    }\n\n    public static createActions(\n        tableview: TableviewDescriptorInst<any, any, any>,\n        injector: Injector,\n        defaultActions?: TableviewDefaultActionsEnum[],\n        defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>\n    ): Array<ActionDescriptorInst<any>> {\n        return (defaultActions ?? TableviewDefaultActions.getDefaultActions())\n            .map(t => TableviewDefaultActions.createAction(t, tableview, injector, defaultActions, defaultActionsOverrides))\n            .filter(e => e != null) as Array<ActionDescriptorInst<any>>;\n    }\n\n    public static createAction(\n        type: TableviewDefaultActionsEnum,\n        tableview: TableviewDescriptorInst<any, any, any>,\n        injector: Injector,\n        defaultActions?: TableviewDefaultActionsEnum[],\n        defaultActionsOverrides?: Record<number, ActionDescriptorInst<any>>\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 TableviewDefaultActions.details(tableview.detailsEditor, injector);\n            case TableviewDefaultActionsEnum.Edit:\n                return TableviewDefaultActions.edit(tableview.editEditor, injector);\n            case TableviewDefaultActionsEnum.Delete:\n                return TableviewDefaultActions.delete(tableview.model, injector);\n            // table toolbar actions\n            case TableviewDefaultActionsEnum.Add:\n                return TableviewDefaultActions.add(tableview.addEditor, injector);\n            case TableviewDefaultActionsEnum.LocalizationLanguageSelect:\n                return TableviewDefaultActions.LocalizationLanguageSelect(tableview);\n            case TableviewDefaultActionsEnum.Refresh:\n                return TableviewDefaultActions.refresh(tableview.model);\n            case TableviewDefaultActionsEnum.Export:\n                return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportJson) || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)\n                    ? TableviewDefaultActions.export(tableview, injector, defaultActions)\n                    : null;\n            //details actions\n            case TableviewDefaultActionsEnum.EditOnDetails:\n                return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Edit)\n                    ? TableviewDefaultActions.editOnDetails(tableview.model, TableviewDefaultActions.edit(tableview.editEditor, injector), injector)\n                    : null;\n            case TableviewDefaultActionsEnum.DeleteOnDetails:\n                return defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.Delete)\n                    ? TableviewDefaultActions.deleteOnDetails(tableview.model, injector)\n                    : null;\n            // subactions\n            case TableviewDefaultActionsEnum.ExportJson:\n            case TableviewDefaultActionsEnum.ExportCsv:\n                return null;\n            default:\n                throw new MngInternalError(`Tableview default action of type ${type} not supported`);\n        }\n    }\n\n    private static getRouteData(injector: Injector) {\n        return injector.get(ActivatedRoute).snapshot.data as MngRouterData;\n    }\n\n    public static details<Model>(descriptor: EditorDescriptorInst<Model>, injector: Injector): ActionEditorDetailsDescriptorInst<Model> | null {\n        const routeData = TableviewDefaultActions.getRouteData(injector);\n        return !routeData.tableviewActions || routeData.tableviewActions.hasDetails ? ActionEditorDetailsDescriptor.create(descriptor) : null;\n    }\n\n    public static add<Model>(descriptor: EditorDescriptorInst<Model>, injector: Injector): ActionEditorAddDescriptorInst<Model> | null {\n        const routeData = TableviewDefaultActions.getRouteData(injector);\n        return !routeData.tableviewActions || routeData.tableviewActions.hasAdd ? ActionEditorAddDescriptor.create(descriptor) : null;\n    }\n\n    public static edit<Model>(descriptor: EditorDescriptorInst<Model>, injector: Injector): ActionEditorEditDescriptorInst<Model> | null {\n        const routeData = TableviewDefaultActions.getRouteData(injector);\n        return !routeData.tableviewActions || routeData.tableviewActions.hasEdit ? ActionEditorEditDescriptor.create(descriptor) : null;\n    }\n\n    public static editOnDetails<Model>(\n        descriptor: ModelDescriptor<Model>,\n        editDescriptor: ActionEditorEditDescriptorInst<Model> | null,\n        injector: Injector\n    ): ActionLinkDescriptorInst<Model> | null {\n        const routeData = TableviewDefaultActions.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\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\n    public static deleteOnDetails<Model>(model: ModelDescriptor<Model>, injector: Injector): ActionDescriptorInst<Model> | null {\n        const action = this.delete(model, injector);\n        const dataProviderExecutor = 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.runDeleteOrFail(ctx).pipe(\n                        tap(() => {\n                            ctx.viewContainer?.reloadTable({});\n                            ctx.viewContainer?.closeEditor();\n                        })\n                    )\n                );\n            action.button.withLabel(undefined);\n            action.button.styleClass.withSize(StyleSizeEnum.Normal);\n\n            return action;\n        }\n\n        return null;\n    }\n\n    public static delete<Model>(descriptor: ModelDescriptor<Model>, injector: Injector): ActionDeleteDescriptorInst<Model> | null {\n        const routeData = TableviewDefaultActions.getRouteData(injector);\n        return !routeData.tableviewActions || routeData.tableviewActions.hasDelete ? new ActionDeleteDescriptorInst(descriptor) : null;\n    }\n\n    public static export<Model>(\n        descriptor: TableviewDescriptorInst<Model>,\n        injector: Injector,\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(this.exportJson(descriptor, injector));\n        if (defaultActions == null || defaultActions.includes(TableviewDefaultActionsEnum.ExportCsv)) subactions.push(this.exportCsv(descriptor, injector));\n\n        exportAction.withSubactions(...subactions);\n        return exportAction;\n    }\n\n    public static exportJson<Model>(descriptor: TableviewDescriptorInst<Model>, injector: Injector): ActionDescriptorInst<Model> {\n        const dataProviderExecutor = 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.withDataListParams(params);\n                return 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                        FileUtil.saveAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.json`);\n                        return undefined;\n                    })\n                );\n            })\n            .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-code'))\n            .withPosition(ActionPositionEnum.ToolbarRight);\n    }\n\n    public static exportCsv<Model>(descriptor: TableviewDescriptorInst<Model>, injector: Injector): ActionDescriptorInst<Model> {\n        const dataProviderExecutor = 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.withDataListParams(params);\n                return dataProviderExecutor.runGetAllOrFail(ctx).pipe(\n                    map(res => {\n                        if (!res.data) {\n                            return undefined;\n                        }\n                        const blob = new Blob([ExportUtils.prepareDataForExport(res.data, ',', descriptor, ctx.injector.get(TranslateService))], {type: 'text/csv;charset=utf-8'});\n                        const typeName = ctx.instance.action.model?.typeName ?? '';\n                        FileUtil.saveAs(blob, `${typeName ? typeName + '_' : ''}${ctx.instance.action.actionName}.csv`);\n                        return undefined;\n                    })\n                );\n            })\n            .withButtonDescriptor(new ActionButtonDescriptor().withIcon('pi pi-file'))\n            .withPosition(ActionPositionEnum.ToolbarRight);\n    }\n\n    public static refresh<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\n    public static LocalizationLanguageSelect<Model>(descriptor: TableviewDescriptorInst<Model>): ActionDescriptorInst<Model> | null {\n        return descriptor.isLocalized()\n            ? ActionDescriptor.fromModel(descriptor.model, 'translator').withPosition(ActionPositionEnum.ToolbarLeft).withComponent(MngDataLanguageDropdownComponent)\n            : null;\n    }\n}\n"]}

package/esm2022/lib/components/tableview/builders/tableview-builder.mjs

@@ -0,0 +1,162 @@
+import { TableviewDefaultActions } from '../actions/tableview-default-actions';
+/**
+ * The `TableviewBuilder` class is used to build a tableview configuration.
+ * It allows you to set various options such as the descriptor, data provider,
+ * default actions, and custom actions for the tableview.
+ *
+ * @typeparam Model - The main model type.
+ * @typeparam Service - The API service type.
+ * @typeparam Descriptor - The descriptor type.
+ * @typeparam DataProvider - The data provider type.
+ * @typeparam Sorts - The sort type representing available sort keys.
+ * @typeparam Filters - The filter type representing available filter keys.
+ */
+export class TableviewBuilder {
+    constructor(_descriptor, _dataProvider, injector) {
+        this._descriptor = _descriptor;
+        this._dataProvider = _dataProvider;
+        this.injector = injector;
+        this.defaultActions = TableviewDefaultActions.getDefaultActions().map(a => ({ type: a, descriptor: undefined }));
+        this._customActions = [];
+    }
+    prepareSetterParams() {
+        return { descriptor: this._descriptor, dataProvider: this._dataProvider, injector: this.injector };
+    }
+    /**
+     * Sets a descriptor instead of the default one.
+     *
+     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDescriptor(fn) {
+        this._descriptor = fn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Adjusts the descriptor using the provided adjust function.
+     *
+     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDescriptor(adjustFn) {
+        adjustFn(this._descriptor);
+        return this;
+    }
+    /**
+     * Sets the data provider for the TvBuilder instance
+     *
+     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * * @returns {this} - Returns the current instance of the builder.
+     */
+    withDataProvider(fn) {
+        this._dataProvider = fn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Adjusts the data provider using the provided adjust function.
+     *
+     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjustDataProvider(adjustFn) {
+        adjustFn(this._dataProvider);
+        return this;
+    }
+    /**
+     * Adjusts the data provider and/or descriptor using the provided adjust function.
+     *
+     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAdjust(adjustFn) {
+        adjustFn(this.prepareSetterParams());
+        return this;
+    }
+    /**
+     * Removes all the default tableview actions.
+     *
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withNoDefaultActions() {
+        this.defaultActions.forEach(a => (a.descriptor = null));
+        return this;
+    }
+    /**
+     * Adds the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActions(...types) {
+        types.forEach(type => {
+            const action = this.defaultActions.find(a => a.type === type);
+            if (action?.descriptor === null) {
+                action.descriptor = undefined;
+            }
+        });
+        return this;
+    }
+    /**
+     * Removes the default actions specified in parameters.
+     *
+     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withoutDefaultActions(...types) {
+        types.forEach(type => {
+            const action = this.defaultActions.find(a => a.type === type);
+            if (action) {
+                action.descriptor = null;
+            }
+        });
+        return this;
+    }
+    /**
+     * Overrides the default action.
+     *
+     * @param {TableviewDefaultActionsEnum} type - The default actions to override.
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withDefaultActionOverride(type, fn) {
+        const action = this.defaultActions.find(a => a.type === type);
+        if (action) {
+            action.descriptor = fn(this.prepareSetterParams()) ?? null;
+        }
+        return this;
+    }
+    /**
+     * Adds a custom action.
+     *
+     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.
+     * @typeParam ActionService - The service type (same as build `Service` by default).
+     * @returns {this} - Returns the current instance of the builder.
+     */
+    withAction(fn) {
+        const action = fn(this.prepareSetterParams());
+        if (action) {
+            this._customActions.push(action);
+        }
+        return this;
+    }
+    /**
+     * Builds and returns an instance of ITableview.
+     * DO NOT CALL this within tableview create callback function!
+     *
+     * @return {ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.
+     */
+    build() {
+        return {
+            actions: TableviewDefaultActions.createActions(this._descriptor, this.injector, this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type), this.defaultActions
+                .filter(a => a.descriptor != null)
+                .reduce((acc, a) => ({
+                ...acc,
+                [a.type]: a.descriptor
+            }), {})).concat(this._customActions),
+            dataProvider: this._dataProvider,
+            descriptor: this._descriptor
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tableview-builder.js","sourceRoot":"","sources":["../../../../../../src/lib/components/tableview/builders/tableview-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injector} from '@angular/core';\n\nimport {IDataProvider} from '../../../data-providers';\nimport {ActionDescriptorInst} from '../../../descriptors/action';\nimport {TableviewDescriptorInst} from '../../../descriptors/tableview';\nimport {Nullable} from '../../../types';\nimport {TableviewDefaultActions, TableviewDefaultActionsEnum} from '../actions/tableview-default-actions';\nimport {ITableview} from '../models/tableview.model';\n\nexport type TvBuilderSetterParamsType<Descriptor, DataProvider> = {descriptor: Descriptor; dataProvider: DataProvider; injector: Injector};\nexport type TvBuilderActionSetterFnType<ActionModel, ActionService, Descriptor, DataProvider> = (\n    params: TvBuilderSetterParamsType<Descriptor, DataProvider>\n) => Nullable<ActionDescriptorInst<ActionModel, ActionService>>;\nexport type TvBuilderDescriptorSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => Descriptor;\nexport type TvBuilderDataProviderSetterFnType<Descriptor, DataProvider> = (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => DataProvider;\n\ntype DefaultAction = {\n    type: TableviewDefaultActionsEnum;\n    descriptor: ActionDescriptorInst<any, any> | null | undefined;\n};\n\n/**\n * The `TableviewBuilder` class is used to build a tableview configuration.\n * It allows you to set various options such as the descriptor, data provider,\n * default actions, and custom actions for the tableview.\n *\n * @typeparam Model - The main model type.\n * @typeparam Service - The API service type.\n * @typeparam Descriptor - The descriptor type.\n * @typeparam DataProvider - The data provider type.\n * @typeparam Sorts - The sort type representing available sort keys.\n * @typeparam Filters - The filter type representing available filter keys.\n */\nexport class TableviewBuilder<\n    Model,\n    Service,\n    Descriptor extends TableviewDescriptorInst<Model, Sorts, Filters>,\n    DataProvider extends IDataProvider<Model, Service>,\n    Sorts = keyof Model,\n    Filters extends keyof any = keyof Model\n> {\n    private defaultActions: DefaultAction[] = TableviewDefaultActions.getDefaultActions().map(a => ({type: a, descriptor: undefined}));\n    private readonly _customActions: ActionDescriptorInst<Model>[] = [];\n\n    constructor(\n        private _descriptor: Descriptor,\n        private _dataProvider: DataProvider,\n        private readonly injector: Injector\n    ) {}\n\n    private prepareSetterParams(): TvBuilderSetterParamsType<Descriptor, DataProvider> {\n        return {descriptor: this._descriptor, dataProvider: this._dataProvider, injector: this.injector};\n    }\n\n    /**\n     * Sets a descriptor instead of the default one.\n     *\n     * @param {TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new descriptor. It should accept a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDescriptor(fn: TvBuilderDescriptorSetterFnType<Descriptor, DataProvider>): this {\n        this._descriptor = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the descriptor using the provided adjust function.\n     *\n     * @param {(descriptor: Descriptor) => void} adjustFn - The function used to adjust the descriptor. It accepts a single parameter of type `Descriptor`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDescriptor(adjustFn: (descriptor: Descriptor) => void): this {\n        adjustFn(this._descriptor);\n        return this;\n    }\n\n    /**\n     * Sets the data provider for the TvBuilder instance\n     *\n     * @param {TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>} fn - The function that returns the new data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * * @returns {this} - Returns the current instance of the builder.\n     */\n    withDataProvider(fn: TvBuilderDataProviderSetterFnType<Descriptor, DataProvider>): this {\n        this._dataProvider = fn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider using the provided adjust function.\n     *\n     * @param {(dataProvider: DataProvider) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `DataProvider`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjustDataProvider(adjustFn: (dataProvider: DataProvider) => void): this {\n        adjustFn(this._dataProvider);\n        return this;\n    }\n\n    /**\n     * Adjusts the data provider and/or descriptor using the provided adjust function.\n     *\n     * @param {(params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void} adjustFn - The function used to adjust the data provider. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAdjust(adjustFn: (params: TvBuilderSetterParamsType<Descriptor, DataProvider>) => void): this {\n        adjustFn(this.prepareSetterParams());\n        return this;\n    }\n\n    /**\n     * Removes all the default tableview actions.\n     *\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withNoDefaultActions(): this {\n        this.defaultActions.forEach(a => (a.descriptor = null));\n        return this;\n    }\n\n    /**\n     * Adds the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to add.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action?.descriptor === null) {\n                action.descriptor = undefined;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Removes the default actions specified in parameters.\n     *\n     * @param {TableviewDefaultActionsEnum[]} types - The default actions to remove.\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withoutDefaultActions(...types: TableviewDefaultActionsEnum[]): this {\n        types.forEach(type => {\n            const action = this.defaultActions.find(a => a.type === type);\n            if (action) {\n                action.descriptor = null;\n            }\n        });\n        return this;\n    }\n\n    /**\n     * Overrides the default action.\n     *\n     * @param {TableviewDefaultActionsEnum} type - The default actions to override.\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withDefaultActionOverride<ActionService = Service>(type: TableviewDefaultActionsEnum, fn: TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>): this {\n        const action = this.defaultActions.find(a => a.type === type);\n        if (action) {\n            action.descriptor = fn(this.prepareSetterParams()) ?? null;\n        }\n        return this;\n    }\n\n    /**\n     * Adds a custom action.\n     *\n     * @param {TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>} fn - The function that returns the new action descriptor. It accepts a single parameter of type `TvBuilderSetterParamsType<Descriptor, DataProvider>`.\n     * @typeParam ActionService - The service type (same as build `Service` by default).\n     * @returns {this} - Returns the current instance of the builder.\n     */\n    withAction<ActionService = Service>(fn: TvBuilderActionSetterFnType<Model, ActionService, Descriptor, DataProvider>): this {\n        const action = fn(this.prepareSetterParams());\n        if (action) {\n            this._customActions.push(action);\n        }\n        return this;\n    }\n\n    /**\n     * Builds and returns an instance of ITableview.\n     * DO NOT CALL this within tableview create callback function!\n     *\n     * @return {ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>} - The built ITableview instance.\n     */\n    build() {\n        return <ITableview<Model, Service, Sorts, Filters, Descriptor, DataProvider>>{\n            actions: TableviewDefaultActions.createActions(\n                this._descriptor as TableviewDescriptorInst<any, any, any>,\n                this.injector,\n                this.defaultActions.filter(a => a.descriptor !== null).map(a => a.type),\n                this.defaultActions\n                    .filter(a => a.descriptor != null)\n                    .reduce(\n                        (acc, a) => ({\n                            ...acc,\n                            [a.type]: a.descriptor!\n                        }),\n                        <Record<number, ActionDescriptorInst<any>>>{}\n                    )\n            ).concat(this._customActions),\n            dataProvider: this._dataProvider,\n            descriptor: this._descriptor\n        };\n    }\n}\n"]}

package/esm2022/lib/components/tableview/helpers/tableview-create.mjs

@@ -0,0 +1,24 @@
+import { Injector, inject } from '@angular/core';
+import { TableviewDataProvider } from '../../../data-providers';
+import { TableviewDescriptor } from '../../../descriptors/tableview';
+import { TableviewBuilder } from '../builders/tableview-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 TableviewBuilder(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+export function tableviewWithSortAndFilter(model, service, sorts, filters, buildFn) {
+    const builder = new TableviewBuilder(TableviewDescriptor.fromModel(model), TableviewDataProvider.fromService(service), inject(Injector));
+    buildFn?.(builder);
+    return builder.build();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/tableview/index.mjs

@@ -1,4 +1,7 @@
+export * from './actions/tableview-default-actions';
+export * from './builders/tableview-builder';
 export * from './tableview.component';
-export * from './route/tableview-route.abstract.component';
 export * from './route/tableview-route.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvdGFibGV2aWV3L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90YWJsZXZpZXcuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcm91dGUvdGFibGV2aWV3LXJvdXRlLmFic3RyYWN0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JvdXRlL3RhYmxldmlldy1yb3V0ZS5jb21wb25lbnQnO1xuIl19
+export * from './models/tableview.model';
+export * from './helpers/tableview-create';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvdGFibGV2aWV3L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hY3Rpb25zL3RhYmxldmlldy1kZWZhdWx0LWFjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVycy90YWJsZXZpZXctYnVpbGRlcic7XG5leHBvcnQgKiBmcm9tICcuL3RhYmxldmlldy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9yb3V0ZS90YWJsZXZpZXctcm91dGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3RhYmxldmlldy5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcnMvdGFibGV2aWV3LWNyZWF0ZSc7XG4iXX0=

package/esm2022/lib/components/tableview/models/tableview.model.mjs

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

package/esm2022/lib/components/tableview/route/tableview-route.component.mjs

@@ -1,47 +1,15 @@
 import { Component, Input } from '@angular/core';
-import { TableviewDescriptorInst } from '../../../descriptors/tableview';
 import { MngTableviewComponent } from '../tableview.component';
-import { AMngTableviewRouteComponent } from './tableview-route.abstract.component';
 import * as i0 from "@angular/core";
-export class MngTableviewRouteComponent extends AMngTableviewRouteComponent {
-    createTableviewDescriptor() {
-        if (this.descriptorInit) {
-            return this.descriptorInit;
-        }
-        if (this.routeData?.tableview?.descriptor) {
-            throw Error('Tableview requires a descriptor.');
-        }
-        return this.routeData.tableview.descriptor;
-    }
-    createTableviewDataProvider() {
-        if (this.dataProviderInit) {
-            return this.dataProviderInit;
-        }
-        if (this.routeData?.tableview?.dataProvider) {
-            throw Error('Tableview requires a data provider.');
-        }
-        return this.routeData.tableview.dataProvider;
-    }
-    createActionDescriptors() {
-        if (this.actionsInit) {
-            return this.actionsInit;
-        }
-        return this.routeData?.tableview?.actions ?? super.createActionDescriptors();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: MngTableviewRouteComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: MngTableviewRouteComponent, isStandalone: true, selector: "mng-tableview-route", inputs: { descriptorInit: ["descriptor", "descriptorInit"], dataProviderInit: ["dataProvider", "dataProviderInit"], actionsInit: ["actions", "actionsInit"] }, usesInheritance: true, ngImport: i0, template: "<div class=\"grid\">\n    <div class=\"col-12\">\n        <mng-tableview [descriptor]=\"descriptor\" [dataProvider]=\"dataProvider\" [actions]=\"actions\"> </mng-tableview>\n    </div>\n</div>\n", dependencies: [{ kind: "component", type: MngTableviewComponent, selector: "mng-tableview", inputs: ["descriptor", "dataProvider", "actions"] }] }); }
+export class MngTableviewRouteComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: MngTableviewRouteComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: MngTableviewRouteComponent, isStandalone: true, selector: "mng-tableview-route", inputs: { tableview: "tableview" }, ngImport: i0, template: "<mng-tableview [descriptor]=\"tableview.descriptor\" [dataProvider]=\"tableview.dataProvider\" [actions]=\"tableview.actions\"> </mng-tableview>\n", dependencies: [{ kind: "component", type: MngTableviewComponent, selector: "mng-tableview", inputs: ["descriptor", "dataProvider", "actions"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: MngTableviewRouteComponent, decorators: [{
             type: Component,
-            args: [{ standalone: true, selector: 'mng-tableview-route', imports: [MngTableviewComponent], template: "<div class=\"grid\">\n    <div class=\"col-12\">\n        <mng-tableview [descriptor]=\"descriptor\" [dataProvider]=\"dataProvider\" [actions]=\"actions\"> </mng-tableview>\n    </div>\n</div>\n" }]
-        }], propDecorators: { descriptorInit: [{
+            args: [{ standalone: true, selector: 'mng-tableview-route', imports: [MngTableviewComponent], template: "<mng-tableview [descriptor]=\"tableview.descriptor\" [dataProvider]=\"tableview.dataProvider\" [actions]=\"tableview.actions\"> </mng-tableview>\n" }]
+        }], propDecorators: { tableview: [{
                 type: Input,
-                args: ['descriptor']
-            }], dataProviderInit: [{
-                type: Input,
-                args: ['dataProvider']
-            }], actionsInit: [{
-                type: Input,
-                args: ['actions']
+                args: [{ required: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGV2aWV3LXJvdXRlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXZpZXcvcm91dGUvdGFibGV2aWV3LXJvdXRlLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29tcG9uZW50cy90YWJsZXZpZXcvcm91dGUvdGFibGV2aWV3LXJvdXRlLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUUsS0FBSyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRy9DLE9BQU8sRUFBQyxxQkFBcUIsRUFBQyxNQUFNLHdCQUF3QixDQUFDOztBQVE3RCxNQUFNLE9BQU8sMEJBQTBCOzhHQUExQiwwQkFBMEI7a0dBQTFCLDBCQUEwQixtSENYdkMsb0pBQ0EsNENET2MscUJBQXFCOzsyRkFHdEIsMEJBQTBCO2tCQU50QyxTQUFTO2lDQUNNLElBQUksWUFDTixxQkFBcUIsV0FDdEIsQ0FBQyxxQkFBcUIsQ0FBQzs4QkFJQSxTQUFTO3NCQUF4QyxLQUFLO3VCQUFDLEVBQUMsUUFBUSxFQUFFLElBQUksRUFBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Q29tcG9uZW50LCBJbnB1dH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7SVRhYmxldmlld30gZnJvbSAnLi4vbW9kZWxzL3RhYmxldmlldy5tb2RlbCc7XG5pbXBvcnQge01uZ1RhYmxldmlld0NvbXBvbmVudH0gZnJvbSAnLi4vdGFibGV2aWV3LmNvbXBvbmVudCc7XG5cbkBDb21wb25lbnQoe1xuICAgIHN0YW5kYWxvbmU6IHRydWUsXG4gICAgc2VsZWN0b3I6ICdtbmctdGFibGV2aWV3LXJvdXRlJyxcbiAgICBpbXBvcnRzOiBbTW5nVGFibGV2aWV3Q29tcG9uZW50XSxcbiAgICB0ZW1wbGF0ZVVybDogJy4vdGFibGV2aWV3LXJvdXRlLmNvbXBvbmVudC5odG1sJ1xufSlcbmV4cG9ydCBjbGFzcyBNbmdUYWJsZXZpZXdSb3V0ZUNvbXBvbmVudDxJdGVtLCBTZXJ2aWNlID0gdW5kZWZpbmVkLCBTb3J0cyA9IGtleW9mIEl0ZW0sIEZpbHRlcnMgZXh0ZW5kcyBrZXlvZiBhbnkgPSBrZXlvZiBJdGVtPiB7XG4gICAgQElucHV0KHtyZXF1aXJlZDogdHJ1ZX0pIHB1YmxpYyB0YWJsZXZpZXchOiBJVGFibGV2aWV3PEl0ZW0sIFNlcnZpY2UsIFNvcnRzLCBGaWx0ZXJzPjtcbn1cbiIsIjxtbmctdGFibGV2aWV3IFtkZXNjcmlwdG9yXT1cInRhYmxldmlldy5kZXNjcmlwdG9yXCIgW2RhdGFQcm92aWRlcl09XCJ0YWJsZXZpZXcuZGF0YVByb3ZpZGVyXCIgW2FjdGlvbnNdPVwidGFibGV2aWV3LmFjdGlvbnNcIj4gPC9tbmctdGFibGV2aWV3PlxuIl19