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

package/table/api/models/table-columns.model.d.ts

@@ -0,0 +1,42 @@
+import { EnumConstantType, ILookupDataProvider } from '@mediusinc/mng-commons/core';
+import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor } from '@mediusinc/mng-commons/filter';
+import { EnumDescriptor } from '@mediusinc/mng-commons/model';
+import { ColumnDescriptor } from '../descriptors/column.descriptor';
+import { SortDescriptor } from '../descriptors/sort.descriptor';
+export interface IColumnsManageInterface<TableModel, Sorts, Filters> {
+    getColumn(property: keyof TableModel): ColumnDescriptor<any, TableModel> | null;
+    getColumnUnsafe(property: string): ColumnDescriptor<any, TableModel> | null;
+    removeColumn(property: keyof TableModel): void;
+    removeColumnUnsafe(property: string): void;
+    withColumn<ColumnModel, ColumnValue = ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): this;
+    addColumn<PropertyKey extends keyof TableModel>(property: PropertyKey): ColumnDescriptor<NonNullable<TableModel[PropertyKey]>, TableModel, TableModel[PropertyKey]>;
+    addColumnEnum<PropertyKey extends keyof TableModel, Enum extends NonNullable<TableModel[PropertyKey]>>(property: PropertyKey, enumDesc: EnumDescriptor<Enum>): ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>;
+    addColumnUnsafe<ColumnModel = any>(property: string): ColumnDescriptor<ColumnModel, TableModel>;
+    withColumns(...properties: (keyof TableModel)[]): this;
+    getSort(property: Sorts): SortDescriptor<TableModel> | null;
+    getSortUnsafe(property: string): SortDescriptor<TableModel> | null;
+    removeSort(property: Sorts): void;
+    removeSortUnsafe(property: string): void;
+    addSort(property: Sorts, isDefault: boolean, ascending?: boolean): SortDescriptor<TableModel>;
+    addSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): SortDescriptor<TableModel>;
+    withSort(property: Sorts, isDefault: boolean, ascending?: boolean): this;
+    withSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): this;
+    withSorts(...properties: Sorts[]): this;
+    withSortsUnsafe(...properties: string[]): this;
+    getFilter(property: Filters): FilterDescriptor<any, TableModel> | null;
+    getFilterUnsafe(property: string): FilterDescriptor<any, TableModel> | null;
+    removeFilter(property: Filters): void;
+    removeFilterUnsafe(property: string): void;
+    addFilter<FilterModel = Filters extends keyof TableModel ? TableModel[Filters] : never>(property: Filters): FilterDescriptor<FilterModel, TableModel>;
+    addFilterUnsafe<FilterModel>(property: string): FilterDescriptor<FilterModel, TableModel>;
+    addFilterLookup<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : never, Service = undefined>(property: Filters, provider?: ILookupDataProvider<FilterModel, Service>, optionsValueProperty?: keyof FilterModel): FilterLookupDescriptor<FilterModel, TableModel, Service>;
+    addFilterLookupUnsafe<FilterModel, Service = undefined>(property: string, provider?: ILookupDataProvider<FilterModel, Service>, optionsValueProperty?: string): FilterLookupDescriptor<FilterModel, TableModel, Service>;
+    addFilterLookupEnum<Enum>(property: Filters, enumDesc: EnumDescriptor<any>, options?: Array<Enum>): FilterLookupEnumDescriptor<Enum, TableModel>;
+    addFilterLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FilterLookupEnumDescriptor<Enum, TableModel>;
+    addFilterFromColumn(property: Extract<Filters, keyof TableModel>, forceSimple: boolean): FilterDescriptor<any, TableModel>;
+    addFilterFromColumnUnsafe(property: string, forceSimple: boolean): FilterDescriptor<any, TableModel>;
+    withFiltersFromColumns(...properties: Extract<Filters, keyof TableModel>[]): this;
+    withFiltersFromColumnsUnsafe(...properties: string[]): this;
+    withFilter<FilterModel>(property: Filters, filter: FilterDescriptor<FilterModel, TableModel>): this;
+    withFilterUnsafe<FilterModel>(filter: FilterDescriptor<FilterModel, TableModel>): this;
+}

package/table/api/models/table-event.model.d.ts

@@ -0,0 +1,17 @@
+import { TableLazyLoadEvent } from 'primeng/table';
+import { DataListParams } from '@mediusinc/mng-commons/core';
+import { ColumnDescriptor } from '../descriptors/column.descriptor';
+export interface TableLoadEvent {
+    params?: DataListParams;
+    originalEvent?: TableLazyLoadEvent;
+}
+export interface TableCellClickEvent<T> {
+    column: ColumnDescriptor<any, T>;
+    rowItem: T;
+    rowIndex: number;
+    event: Event;
+}
+export interface TableReloadEvent {
+    resetParams: boolean;
+    emitEvent: boolean;
+}

package/table/api/models/table.model.d.ts

@@ -0,0 +1,35 @@
+import { FilterDescriptor } from '@mediusinc/mng-commons/filter';
+import { ModelDescriptor } from '@mediusinc/mng-commons/model';
+import { ColumnDescriptor } from '../descriptors/column.descriptor';
+export declare enum TablePaginationModeEnum {
+    Pagination = 0,
+    InfiniteScroll = 1,
+    None = 2
+}
+export declare enum TableSizeEnum {
+    Small = 0,
+    Normal = 1,
+    Large = 2
+}
+/**
+ * EXCLUDE default, all columns has sort and filter on by default, developer EXCLUDES properties from sort/filter
+ * INCLUDE_ONLY only selected columns have sort/filter, developers INCLUDES properties
+ */
+export declare enum TableDynamicColumnsModeEnum {
+    EXCLUDE = 0,
+    INCLUDE_ONLY = 1
+}
+/**
+ * This one is internal only to prevent circular dependencies between editor and fields.
+ */
+export interface ITableDescriptorInternal<TableModel> {
+    model: ModelDescriptor<TableModel>;
+    withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: boolean): this;
+    withSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): this;
+    addFilterFromColumnDescriptorUnsafe<ColumnModel, ColumnValue>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>, forceSimple: boolean): FilterDescriptor<any, TableModel>;
+}
+export interface TableLayoutPreferences {
+    columnWidths?: Record<string, number>;
+    columnOrder?: string[];
+    columnVisibility?: string[];
+}

package/table/components/column-filter-full/column-filter-full.component.d.ts

@@ -0,0 +1,100 @@
+import { ElementRef, OnDestroy, OnInit, WritableSignal } from '@angular/core';
+import { FilterMetadata as PrimeFilterMetadata, SelectItem } from 'primeng/api';
+import { Nullable } from 'primeng/ts-helpers';
+import { FilterDescriptor, FilterLookupDescriptor, FilterLookupTypeEnum } from '@mediusinc/mng-commons/filter';
+import * as i0 from "@angular/core";
+/**
+ * Cannot be on push change detection strategy because of filter updates triggered from route which causes to force update values in force metadata
+ * and these must be propagated through to this component and beyond to primeNG.
+ */
+export declare class TableColumnFilterFullComponent implements OnInit, OnDestroy {
+    readonly lookupTypeDropdown: FilterLookupTypeEnum;
+    readonly lookupTypeAutocomplete: FilterLookupTypeEnum;
+    private readonly el;
+    private readonly primeTable;
+    private readonly dataListService;
+    private readonly moduleConfig;
+    private readonly renderer;
+    private readonly primeConfig;
+    private readonly overlayService;
+    private readonly cd;
+    private readonly document;
+    descriptor: FilterDescriptor<any, any>;
+    icon: Nullable<ElementRef>;
+    primeField: string;
+    primeType: string;
+    lookupDescriptor?: FilterLookupDescriptor<any, any>;
+    matchModes: WritableSignal<SelectItem[]>;
+    filterConstraint: WritableSignal<FilterMetadata | undefined>;
+    isFilterSet: import("@angular/core").Signal<boolean>;
+    isInputDisabled: import("@angular/core").Signal<boolean>;
+    overlayVisible: WritableSignal<boolean>;
+    private overlaySubscription?;
+    private overlay;
+    private scrollHandler?;
+    private documentClickListener;
+    private documentResizeListener;
+    private translationSubscription?;
+    private resetSubscription?;
+    private selfClick?;
+    private overlayEventListener;
+    private tableFilterMetadataSubscription?;
+    private readonly window;
+    private dateDebounceSubject;
+    private dateTimeInUtc;
+    private dateTimeWithTimezone;
+    private dateTimeWithMillis;
+    private dateOnlyDisabled;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onTextModelChange(event: Event): void;
+    onTextInputEnterKeyDown(event: Event): void;
+    onNumericModelChange(value: number | null): void;
+    onNumericInputKeyDown(event: KeyboardEvent): void;
+    onTristateModelChange(value: boolean | null): void;
+    dateFilter(value: Date | Date[] | null): void;
+    autocompleteFilter(value: any): void;
+    dropdownFilter(value: any): void;
+    onMatchModeChange(matchMode: string): void;
+    onMatchModeKeyDown(event: KeyboardEvent): void;
+    onRowClearItemClick(): void;
+    toggleMenu(event: Event): void;
+    onToggleButtonKeyDown(event: KeyboardEvent): void;
+    onEscape(): void;
+    onContentClick(): void;
+    onOverlayAnimationStart(event: any): void;
+    onOverlayAnimationEnd(event: any): void;
+    get noFilterLabel(): string;
+    clearFilter(): void;
+    private generateMatchModeOptions;
+    private getDefaultMatchMode;
+    private findNextMenuModeItem;
+    private findPrevMenuModeItem;
+    private isOutsideClicked;
+    private bindDocumentClickListener;
+    private unbindDocumentClickListener;
+    private bindDocumentResizeListener;
+    private unbindDocumentResizeListener;
+    private bindScrollListener;
+    private unbindScrollListener;
+    private hideOverlay;
+    private onOverlayHide;
+    private updateFilterValue;
+    private updateDtFilter;
+    private initFilterConstraint;
+    private setFilterConstraint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnFilterFullComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnFilterFullComponent, "mng-table-column-filter-full", never, { "descriptor": { "alias": "descriptor"; "required": true; }; }, {}, never, never, true, never>;
+}
+interface FilterMetadata extends PrimeFilterMetadata {
+    /**
+     * The value used for display.
+     */
+    displayValue?: any;
+    /**
+     * The match mode for display.
+     */
+    displayMatchMode?: string;
+}
+export {};

package/table/components/column-value/column-value.component.d.ts

@@ -0,0 +1,33 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { MessageService } from 'primeng/api';
+import { GetterPipe, TemplatePipe } from '@mediusinc/mng-commons/core';
+import { ColumnDescriptor, ColumnDisplayTypeEnum } from '@mediusinc/mng-commons/table/api';
+import * as i0 from "@angular/core";
+export declare class TableColumnValueComponent<T, TT> implements OnInit {
+    private elementRef;
+    private messageService;
+    private translate;
+    private getterPipe;
+    private templatePipe;
+    readonly columnDisplayTypeString: ColumnDisplayTypeEnum;
+    readonly columnDisplayTypeNumber: ColumnDisplayTypeEnum;
+    readonly columnDisplayTypeCurrency: ColumnDisplayTypeEnum;
+    readonly columnDisplayTypeBoolean: ColumnDisplayTypeEnum;
+    readonly columnDisplayTypeDate: ColumnDisplayTypeEnum;
+    readonly columnDisplayTypeEnum: ColumnDisplayTypeEnum;
+    readonly columnDisplayTypeComponent: ColumnDisplayTypeEnum;
+    readonly columnDisplayTypeHtml: ColumnDisplayTypeEnum;
+    descriptor: ColumnDescriptor<T, TT>;
+    item: any;
+    styleMaxWidth: number | null;
+    className: string;
+    currency?: string;
+    jsonPath: string;
+    value: any;
+    constructor(elementRef: ElementRef, messageService: MessageService, translate: TranslateService, getterPipe: GetterPipe, templatePipe: TemplatePipe);
+    ngOnInit(): void;
+    copyToClipboard(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnValueComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnValueComponent<any, any>, "mng-table-column-value", never, { "descriptor": { "alias": "descriptor"; "required": true; }; "item": { "alias": "item"; "required": true; }; }, {}, never, never, true, never>;
+}

package/table/components/table/table.component.d.ts

@@ -0,0 +1,114 @@
+import { AfterContentInit, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, SimpleChanges, TemplateRef, Type, WritableSignal } from '@angular/core';
+import { MultiSelectChangeEvent } from 'primeng/multiselect';
+import { Table, TableColumnReorderEvent, TableLazyLoadEvent } from 'primeng/table';
+import { Observable } from 'rxjs';
+import { ComponentDirective, DataListResult, TemplateDirective } from '@mediusinc/mng-commons/core';
+import { ColumnDescriptor, ITableDataProvider, TableCellClickEvent, TableDescriptorInst, TableLoadEvent } from '@mediusinc/mng-commons/table/api';
+import { ColumnWithPreferences } from '../../models/column-preferences.model';
+import { DataListService } from '../../services/data-list.service';
+import * as i0 from "@angular/core";
+export declare class TableComponent<Item = any, Service = undefined, Sorts = any, Filters extends keyof any = any> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
+    readonly cmpTypeName = "TableComponent";
+    private readonly logger;
+    private readonly injector;
+    private readonly destroyRef;
+    private readonly router;
+    private readonly route;
+    private readonly translate;
+    private readonly messageService;
+    private readonly commons;
+    private readonly localStorageService;
+    readonly dataListService: DataListService<any>;
+    descriptorInput: TableDescriptorInst<Item, Sorts, Filters>;
+    items?: Observable<Array<Item>>;
+    result?: Observable<DataListResult<Item> | undefined>;
+    loadingInput?: Observable<boolean>;
+    dataProvider?: ITableDataProvider<Item, Service, Sorts, Filters>;
+    useQueryParams: boolean;
+    selectionMode: 'single' | 'multiple';
+    selectionEnabled: boolean;
+    columnLastMinWidth?: number;
+    captionComponent?: Type<any>;
+    columnCustomLastComponent?: Type<any>;
+    globalFilterFieldsInput?: string[];
+    loadEventEmitter: EventEmitter<TableLoadEvent>;
+    cellClickEventEmitter: EventEmitter<TableCellClickEvent<Item>>;
+    selectionChangeEventEmitter: EventEmitter<Item[]>;
+    captionCmpInstEventEmitter: EventEmitter<any>;
+    columnCustomLastCmpInstEventEmitter: EventEmitter<any>;
+    templates: QueryList<TemplateDirective>;
+    components: QueryList<ComponentDirective<any>>;
+    primeTable: Table;
+    captionTemplate: WritableSignal<TemplateRef<any> | undefined>;
+    columnCustomLastTemplate: WritableSignal<TemplateRef<any> | undefined>;
+    footerTemplate: WritableSignal<TemplateRef<any> | undefined>;
+    private useDataProvider;
+    isLazy: WritableSignal<boolean>;
+    isPagination: WritableSignal<boolean>;
+    useQueryParamsInitialized: WritableSignal<boolean>;
+    infiniteScroll: WritableSignal<boolean>;
+    className: WritableSignal<string>;
+    tableFullHeightOffset: WritableSignal<number | undefined>;
+    rowHeight: WritableSignal<number | undefined>;
+    private dataProviderService;
+    private dataProviderLatestLazyLoadEvent?;
+    private latestLazyLoadEventVersion;
+    private latestParamsWithDefaults?;
+    private latestParamsWithDefaultsVersion;
+    private dataProviderSubscription?;
+    private resultSubscription?;
+    private itemsSubscription?;
+    descriptor: WritableSignal<TableDescriptorInst<any, any, any>>;
+    columns: WritableSignal<ColumnWithPreferences[]>;
+    visibleColumns: import("@angular/core").Signal<ColumnWithPreferences[]>;
+    hasColumnFilters: import("@angular/core").Signal<boolean>;
+    private filterDescriptors;
+    private defaultParams;
+    private isFilterChanged;
+    private isSortChanged;
+    anyColumnVisible: import("@angular/core").Signal<boolean>;
+    hasCustomLastColumn: WritableSignal<boolean>;
+    hasLastColumn: import("@angular/core").Signal<boolean>;
+    areColumnsReorderable: import("@angular/core").Signal<boolean>;
+    areColumnsToggleable: import("@angular/core").Signal<boolean>;
+    private layoutPreferences;
+    private localstorageKey;
+    private routerIsNavigationOutsideInProgress;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    reload(emitEvent?: boolean, resetParams?: boolean): void;
+    onTableLazyLoad(event: TableLazyLoadEvent): void;
+    onTableSort(event: any): void;
+    onTableFilter(event: any): void;
+    onCellClick(event: Event, col: ColumnDescriptor<any, Item>, item: Item, idx: number): void;
+    onSelectionChange(event: Array<Item>): void;
+    /**
+     * Method is called on column resize
+     * @param element event's element
+     */
+    onTableColumnResize({ element }: any): void;
+    private loadTableWithDataProvider;
+    private loadTableFromRouteUpdate;
+    private setMainAndRelatedDescriptors;
+    private updatePrimeSortAndFilter;
+    private createFilterMeta;
+    private createSortMeta;
+    private initializeDataLoadingTriggers;
+    onColumnToggle(event: MultiSelectChangeEvent): void;
+    onColumnToggleAll(): void;
+    onColumnReorder(event: TableColumnReorderEvent): void;
+    private saveLayoutPreferences;
+    private subscribeToQueryInput;
+    private subscribeToItemsInput;
+    /**
+     * Reset column order and column visibility to default settings
+     */
+    resetDefaultLayout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any, any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any, any, any, any>, "mng-table", never, { "descriptorInput": { "alias": "descriptor"; "required": true; }; "items": { "alias": "items"; "required": false; }; "result": { "alias": "result"; "required": false; }; "loadingInput": { "alias": "loading"; "required": false; }; "dataProvider": { "alias": "dataProvider"; "required": false; }; "useQueryParams": { "alias": "useQueryParams"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectionEnabled": { "alias": "selectionEnabled"; "required": false; }; "columnLastMinWidth": { "alias": "columnLastMinWidth"; "required": false; }; "captionComponent": { "alias": "captionComponent"; "required": false; }; "columnCustomLastComponent": { "alias": "columnCustomLastComponent"; "required": false; }; "globalFilterFieldsInput": { "alias": "globalFilterFields"; "required": false; }; }, { "loadEventEmitter": "tableLoad"; "cellClickEventEmitter": "cellClick"; "selectionChangeEventEmitter": "selectionChange"; "captionCmpInstEventEmitter": "captionComponentInstance"; "columnCustomLastCmpInstEventEmitter": "columnCustomLastComponentInstance"; }, ["templates"], never, true, never>;
+    static ngAcceptInputType_items: unknown;
+    static ngAcceptInputType_result: unknown;
+    static ngAcceptInputType_loadingInput: unknown;
+}

package/table/helpers/notification.d.ts

@@ -0,0 +1,4 @@
+import { TranslateService } from '@ngx-translate/core';
+import { Message, MessageService } from 'primeng/api';
+import { TableDescriptorInst } from '@mediusinc/mng-commons/table/api';
+export declare function tableNotificationError(translate: TranslateService, table: TableDescriptorInst<any>, error: any, messageService: MessageService): Message;

package/table/helpers/table-layout-prefs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * generates table layout preferences key used when saving preferences to localstorage
+ * @param typeName string, required
+ * @param url string, required
+ * @param trackProperty string, not required
+ */
+export declare function generateTableLayoutPrefsKey(typeName: string, url: string, trackProperty?: string): string;

package/table/index.d.ts

@@ -0,0 +1,8 @@
+export * from './components/column-filter-full/column-filter-full.component';
+export * from './components/column-value/column-value.component';
+export * from './components/table/table.component';
+export * from './helpers/notification';
+export * from './helpers/table-layout-prefs';
+export * from './pipes/locale-default-row-class.pipe';
+export * from './pipes/table-column-filter-class.pipe';
+export * from './services/data-list.service';

package/table/models/column-preferences.model.d.ts

@@ -0,0 +1,12 @@
+import { FilterDescriptor } from '@mediusinc/mng-commons/filter';
+import { ColumnDescriptor, SortDescriptor } from '@mediusinc/mng-commons/table/api';
+export interface ColumnWithPreferences {
+    id: string;
+    descriptor: ColumnDescriptor<any, any>;
+    filter?: FilterDescriptor<any, any>;
+    sort?: SortDescriptor<any>;
+    disabled: boolean;
+    isVisible: boolean;
+    width?: number;
+    orderIdx?: number;
+}

package/table/pipes/locale-default-row-class.pipe.d.ts

@@ -0,0 +1,10 @@
+import { Injector, PipeTransform } from '@angular/core';
+import { TableDescriptorInst } from '@mediusinc/mng-commons/table/api';
+import * as i0 from "@angular/core";
+export declare class LocaleDefaultRowClassPipe<T> implements PipeTransform {
+    private injector;
+    constructor(injector: Injector);
+    transform(value?: any, descriptor?: TableDescriptorInst<T>, item?: T): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleDefaultRowClassPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocaleDefaultRowClassPipe<any>, "mngLocaleDefaultRowClass", true>;
+}

package/table/pipes/table-column-filter-class.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { FilterDescriptor } from '@mediusinc/mng-commons/filter';
+import * as i0 from "@angular/core";
+export declare class TableColumnFilterClassPipe implements PipeTransform {
+    transform(value: unknown, filter: FilterDescriptor<any, any> | undefined, isEnabled: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnFilterClassPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TableColumnFilterClassPipe, "mngTableColumnFilterClass", true>;
+}

package/table/services/data-list.service.d.ts

@@ -0,0 +1,16 @@
+import { WritableSignal } from '@angular/core';
+import { FilterMetadata, SortMeta } from 'primeng/api';
+import * as i0 from "@angular/core";
+export declare class DataListService<Item> {
+    sortMeta: WritableSignal<SortMeta[] | null>;
+    filterMeta: WritableSignal<Record<string, FilterMetadata>>;
+    rowsPerPageOptions: WritableSignal<number[]>;
+    rows: WritableSignal<number>;
+    offset: WritableSignal<number>;
+    globalFilterFields: WritableSignal<string[]>;
+    data: WritableSignal<Item[]>;
+    count: WritableSignal<number>;
+    loading: WritableSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataListService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataListService<any>>;
+}

package/tableview/README.md

@@ -0,0 +1,13 @@
+# @mediusinc/mng-commons/tableview
+
+Secondary entry point of `@mediusinc/mng-commons`. It can be used by importing from `@mediusinc/mng-commons/tableview`.
+
+## Dependencies within commons
+
+- `@mediusinc/mng-commons/core`
+- `@mediusinc/mng-commons/model`
+- `@mediusinc/mng-commons/form`
+- `@mediusinc/mng-commons/form/api`
+- `@mediusinc/mng-commons/table`
+- `@mediusinc/mng-commons/table/api`
+- `@mediusinc/mng-commons/tableview/api`

package/tableview/action/components/action/action.component.d.ts

@@ -0,0 +1,73 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { MenuItem } from 'primeng/api';
+import { Menu } from 'primeng/menu';
+import { Observable } from 'rxjs';
+import { ActionData, ActionParameters, DataListParams, IDataProvider, IdType, PermissionService } from '@mediusinc/mng-commons/core';
+import { ActionDescriptorInst, ActionLinkDescriptorInst, IActionComponent } from '@mediusinc/mng-commons/tableview/api';
+import { ActionInstance } from '../../models/execution/action-instance.model';
+import { ActionExecutorService } from '../../services/action-executor.service';
+import { ViewContainer } from '../../services/view-container.service';
+import * as i0 from "@angular/core";
+export declare class ActionComponent<Item = any, Service = undefined> implements OnInit, OnChanges, OnDestroy {
+    private routeService;
+    private translate;
+    private authorization;
+    private actionExecutor;
+    private viewContainer;
+    hostClass: string;
+    isHostHidden: boolean;
+    action: ActionDescriptorInst<Item, Service>;
+    item?: Item;
+    itemId?: IdType;
+    actionData?: ActionData;
+    dataListParams?: DataListParams;
+    dataProvider?: IDataProvider<Item, Service>;
+    hostComponent?: unknown;
+    routeInit?: ActivatedRoute;
+    inputDisabled: Observable<boolean>;
+    inputLoading: Observable<boolean>;
+    selectedItems: Array<Item>;
+    finishEventEmitter: EventEmitter<ActionInstance<Item, Service>>;
+    subactionsMenu?: Menu;
+    private loadingSubject;
+    $loading: Observable<boolean>;
+    private isVisibleSubject;
+    private isVisibleSubscription?;
+    $isVisible: Observable<boolean>;
+    private isPermittedSubject;
+    private isPermittedSubscription?;
+    $isPermitted: Observable<boolean>;
+    private isEnabledSubject;
+    private isEnabledSubscription?;
+    $isEnabled: Observable<boolean>;
+    private labelSubject;
+    private labelSubscription?;
+    $label: Observable<string | null>;
+    private tooltipSubject;
+    private tooltipSubscription?;
+    $tooltip: Observable<string | null>;
+    actionLink?: ActionLinkDescriptorInst<Item>;
+    hasNoTitle: boolean;
+    private subscriptions;
+    route: ActivatedRoute;
+    private routePermissions?;
+    buttonClass: string;
+    subactions: MenuItem[];
+    private subactionSubscriptions;
+    actionOrSubactionHasRunConfirmation: boolean;
+    private instance?;
+    constructor(routeService: ActivatedRoute, translate: TranslateService, authorization: PermissionService, actionExecutor: ActionExecutorService, viewContainer: ViewContainer<Item, Service> | null);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    triggerAction(action: ActionDescriptorInst<Item, Service>, parameters?: ActionParameters<Item>, event?: Event): void;
+    onCustomActionCmpInst(instance: IActionComponent<Item>): void;
+    private processSubactions;
+    private processSubscriptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionComponent<any, any>, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionComponent<any, any>, "mng-action", never, { "action": { "alias": "action"; "required": true; }; "item": { "alias": "item"; "required": false; }; "itemId": { "alias": "itemId"; "required": false; }; "actionData": { "alias": "actionData"; "required": false; }; "dataListParams": { "alias": "dataListParams"; "required": false; }; "dataProvider": { "alias": "dataProvider"; "required": false; }; "hostComponent": { "alias": "hostComponent"; "required": false; }; "routeInit": { "alias": "route"; "required": false; }; "inputDisabled": { "alias": "disabled"; "required": false; }; "inputLoading": { "alias": "loading"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; }, { "finishEventEmitter": "finish"; }, never, never, true, never>;
+    static ngAcceptInputType_inputDisabled: unknown;
+    static ngAcceptInputType_inputLoading: unknown;
+}

package/tableview/action/components/editor/action-editor.component.d.ts

@@ -0,0 +1,31 @@
+import { DestroyRef, EventEmitter, Injector, OnChanges, OnInit, SimpleChanges, Type } from '@angular/core';
+import { ActionData, IDataProvider, IdType } from '@mediusinc/mng-commons/core';
+import { ActionEditorDescriptorInst } from '@mediusinc/mng-commons/tableview/api';
+import { ActionEditorInjectorContextComponent, ActionEditorInjectorContextInputData } from './injector-context/action-editor-injector-context.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@mediusinc/mng-commons/core";
+export declare class ActionEditorComponent<T = any, S = any> implements OnInit, OnChanges {
+    readonly injContextCmpType: Type<any>;
+    injector: Injector;
+    readonly destroyRef: DestroyRef;
+    private readonly dialogConfig;
+    action: ActionEditorDescriptorInst<T, S>;
+    itemIdInput?: IdType;
+    itemInput?: T;
+    actionData?: ActionData;
+    dataProvider?: IDataProvider<T, S>;
+    actionRunEventEmitter: EventEmitter<T | null | undefined>;
+    actionCancelEventEmitter: EventEmitter<T | null | undefined>;
+    private actionEditorWInjContextCmp?;
+    actionEditorWInjContextInputData?: ActionEditorInjectorContextInputData<T, S>;
+    private isDialog;
+    get actionEditor(): ActionEditorInjectorContextComponent<T, S> | undefined;
+    get formEditorCmp(): import("@mediusinc/mng-commons/tableview").FormEditorComponent<any> | undefined;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onActionEditorWInjContextCmp(cmp: ActionEditorInjectorContextComponent<T, S>): void;
+    cancel(): void;
+    triggerSubmit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionEditorComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionEditorComponent<any, any>, "mng-action-editor", never, { "action": { "alias": "action"; "required": true; }; "itemIdInput": { "alias": "itemId"; "required": false; }; "itemInput": { "alias": "item"; "required": false; }; "actionData": { "alias": "actionData"; "required": false; }; "dataProvider": { "alias": "dataProvider"; "required": false; }; }, { "actionRunEventEmitter": "actionSubmit"; "actionCancelEventEmitter": "actionCancel"; }, never, never, true, [{ directive: typeof i1.DialogKeydownHandlerDirective; inputs: {}; outputs: {}; }]>;
+}

package/tableview/action/components/editor/injector-context/action-editor-injector-context.component.d.ts

@@ -0,0 +1,76 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit, WritableSignal } from '@angular/core';
+import { DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { Observable } from 'rxjs';
+import { ActionData, IDataProvider, IdType } from '@mediusinc/mng-commons/core';
+import { ActionActivationTriggerEnum, ActionDescriptorInst, ActionEditorDescriptorInst, ActionEditorSubmitTypeEnum, FormEditorSubmitEvent, IActionEditorComponent, IActionInstance } from '@mediusinc/mng-commons/tableview/api';
+import { FormEditorComponent } from '../../../../editor/components/editor/form-editor.component';
+import { ActionInstance } from '../../../models/execution/action-instance.model';
+import * as i0 from "@angular/core";
+export declare class ActionEditorInjectorContextComponent<Item = any, Service = any> implements OnInit, OnDestroy, IActionEditorComponent {
+    protected readonly ActionActivationTriggerEnum: typeof ActionActivationTriggerEnum;
+    readonly actionEditorSubmitTypeSubmit = ActionEditorSubmitTypeEnum.Submit;
+    private readonly destroyRef;
+    private readonly route;
+    private readonly translate;
+    private readonly confirmationService;
+    private readonly dialogService;
+    private readonly logger;
+    private readonly commonsService;
+    private readonly actionExecutor;
+    private readonly viewContainer;
+    data: ActionEditorInjectorContextInputData<Item, Service>;
+    actionRunEventEmitter: EventEmitter<Item | null | undefined>;
+    actionCancelEventEmitter: EventEmitter<Item | null | undefined>;
+    submitButtonElementRef: ElementRef;
+    formEditorCmp?: FormEditorComponent;
+    title: WritableSignal<string | undefined>;
+    isFormDisabled: WritableSignal<boolean>;
+    item: WritableSignal<Item | undefined>;
+    itemId: WritableSignal<IdType | undefined>;
+    actionData: WritableSignal<ActionData | undefined>;
+    toolbarLeftActions: WritableSignal<ActionDescriptorInst<Item, Service>[]>;
+    toolbarRightActions: WritableSignal<ActionDescriptorInst<Item, Service>[]>;
+    footerLeftActions: WritableSignal<ActionDescriptorInst<Item, Service>[]>;
+    footerRightActions: WritableSignal<ActionDescriptorInst<Item, Service>[]>;
+    private instance?;
+    private instanceStateSubscription?;
+    private instanceReactivationSubscription?;
+    private instanceSubmitFormItem?;
+    private instanceSubmitResult?;
+    loading: WritableSignal<boolean>;
+    private fetchExecutionSubscription?;
+    submitLoading: WritableSignal<boolean>;
+    private submitExecutionSubscription?;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSubmit(event: FormEditorSubmitEvent<Item>): void;
+    cancel(): void;
+    updateItemId(itemId: IdType | undefined): void;
+    updateItem(item: Item | undefined): void;
+    triggerSubmit(): void;
+    private initializeSubActions;
+    private fetchItem;
+    private updateTitle;
+    private placeActionsOnPositions;
+    private setEditorEnabled;
+    private processActionInstance;
+    private unsetInstance;
+    private beforeWindowUnload;
+    private onEscapePressed;
+    private showUnsavedChangesConfirmationDialog;
+    closeWithUnsavedChangesConfirmation(callFromGuard?: boolean): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionEditorInjectorContextComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionEditorInjectorContextComponent<any, any>, "mng-action-editor-injector-context", never, { "data": { "alias": "data"; "required": true; }; }, { "actionRunEventEmitter": "actionSubmit"; "actionCancelEventEmitter": "actionCancel"; }, never, never, true, never>;
+}
+export interface ActionEditorInjectorContextInputData<Item, Service> {
+    descriptor: ActionEditorDescriptorInst<Item, Service>;
+    isDialog: boolean;
+    dialogConfig?: DynamicDialogConfig;
+    itemId?: IdType;
+    item?: Item;
+    actionData?: ActionData;
+    dataProvider?: IDataProvider<Item, Service>;
+    actionInstance?: ActionInstance<Item, Service>;
+    previousActionInstance?: IActionInstance<any, any>;
+}