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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mediusinc/mng-commons",
-  "version": "4.2.0",
+  "version": "5.0.0-rc.0",
   "peerDependencies": {
     "@angular/animations": "^17.2.0",
     "@angular/common": "^17.2.0",
@@ -10,7 +10,7 @@
     "@angular/router": "^17.2.0",
     "@ngx-formly/core": "^6.3.0",
     "@ngx-translate/core": "^15.0.0",
-    "primeng": "^17.6.0"
+    "primeng": "^17.12.0"
   },
   "dependencies": {
     "reflect-metadata": "^0.1.13",
@@ -31,6 +31,60 @@
       "esm2022": "./esm2022/mediusinc-mng-commons.mjs",
       "esm": "./esm2022/mediusinc-mng-commons.mjs",
       "default": "./fesm2022/mediusinc-mng-commons.mjs"
+    },
+    "./core": {
+      "types": "./core/index.d.ts",
+      "esm2022": "./esm2022/core/mediusinc-mng-commons-core.mjs",
+      "esm": "./esm2022/core/mediusinc-mng-commons-core.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-core.mjs"
+    },
+    "./filter": {
+      "types": "./filter/index.d.ts",
+      "esm2022": "./esm2022/filter/mediusinc-mng-commons-filter.mjs",
+      "esm": "./esm2022/filter/mediusinc-mng-commons-filter.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-filter.mjs"
+    },
+    "./form": {
+      "types": "./form/index.d.ts",
+      "esm2022": "./esm2022/form/mediusinc-mng-commons-form.mjs",
+      "esm": "./esm2022/form/mediusinc-mng-commons-form.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-form.mjs"
+    },
+    "./model": {
+      "types": "./model/index.d.ts",
+      "esm2022": "./esm2022/model/mediusinc-mng-commons-model.mjs",
+      "esm": "./esm2022/model/mediusinc-mng-commons-model.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-model.mjs"
+    },
+    "./table": {
+      "types": "./table/index.d.ts",
+      "esm2022": "./esm2022/table/mediusinc-mng-commons-table.mjs",
+      "esm": "./esm2022/table/mediusinc-mng-commons-table.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-table.mjs"
+    },
+    "./tableview": {
+      "types": "./tableview/index.d.ts",
+      "esm2022": "./esm2022/tableview/mediusinc-mng-commons-tableview.mjs",
+      "esm": "./esm2022/tableview/mediusinc-mng-commons-tableview.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-tableview.mjs"
+    },
+    "./form/api": {
+      "types": "./form/api/index.d.ts",
+      "esm2022": "./esm2022/form/api/mediusinc-mng-commons-form-api.mjs",
+      "esm": "./esm2022/form/api/mediusinc-mng-commons-form-api.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-form-api.mjs"
+    },
+    "./table/api": {
+      "types": "./table/api/index.d.ts",
+      "esm2022": "./esm2022/table/api/mediusinc-mng-commons-table-api.mjs",
+      "esm": "./esm2022/table/api/mediusinc-mng-commons-table-api.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-table-api.mjs"
+    },
+    "./tableview/api": {
+      "types": "./tableview/api/index.d.ts",
+      "esm2022": "./esm2022/tableview/api/mediusinc-mng-commons-tableview-api.mjs",
+      "esm": "./esm2022/tableview/api/mediusinc-mng-commons-tableview-api.mjs",
+      "default": "./fesm2022/mediusinc-mng-commons-tableview-api.mjs"
     }
   }
 }

package/provide.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from '@angular/core';
+import { CommonsModuleConfig } from '@mediusinc/mng-commons/core';
+import { TableviewFeatureConfig } from '@mediusinc/mng-commons/tableview';
+export type CommonsAllConfig = CommonsModuleConfig & {
+    tableview?: TableviewFeatureConfig;
+};
+export declare function provideCommonsWithTableview(config: CommonsAllConfig): Provider[];

package/table/README.md

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

package/table/api/README.md

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

package/table/api/data-providers/table.data-provider.d.ts

@@ -0,0 +1,38 @@
+import { Observable, Subject } from 'rxjs';
+import { ClassOptType, ClassType, DataListParams, DataListResult, DataProviderInst, IDataProvider, ItemOrObservable, ServiceClassOptType, ServiceClassType } from '@mediusinc/mng-commons/core';
+export type TableDataProviderGetAllFnType<Model = any, Service = undefined, Sorts = keyof Model, Filters extends keyof any = keyof Model, Return = ItemOrObservable<DataListResult<Model>>> = (params: DataListParams<Sorts, Filters>, service: Service, locale?: string) => Return;
+export type TableDataProviderGetAllEagerFnType<Model = any, Service = undefined, Return = ItemOrObservable<Model[]>> = (service: Service, locale?: string) => Return;
+export interface ITableDataProviderGetAll<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model> {
+    getAll: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>): this;
+}
+export interface ITableDataProviderSupport<Sorts = any, Filters extends keyof any = any> {
+    get isLazy(): boolean;
+    get getAllReload$(): Observable<DataListParams<Sorts, Filters> | undefined>;
+    getAllReload(queryParam?: DataListParams<Sorts, Filters>): void;
+}
+export type ITableDataProvider<Model = any, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> = IDataProvider<Model, Service, ModelClass, ServiceClass> & ITableDataProviderSupport<Sorts, Filters> & ITableDataProviderGetAll<Model, Service, Sorts, Filters>;
+export declare class TableDataProviderInst<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> extends DataProviderInst<Model, Service, ModelClass, ServiceClass> implements ITableDataProvider<Model, Service, Sorts, Filters, ModelClass, ServiceClass> {
+    protected readonly _getAllReloadSubject: Subject<DataListParams<Sorts, Filters> | undefined>;
+    protected _isLazy: boolean;
+    protected constructor(type: ModelClass, serviceType: ServiceClass);
+    protected _getAll: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>;
+    get isLazy(): boolean;
+    get getAll(): TableDataProviderGetAllFnType<Model, Service, Sorts, Filters, ItemOrObservable<DataListResult<Model>>>;
+    get getAllReload$(): Observable<DataListParams<Sorts, Filters> | undefined>;
+    withGetAll(fn: TableDataProviderGetAllFnType<Model, Service, Sorts, Filters>): this;
+    withGetAllEagerly(fn: TableDataProviderGetAllEagerFnType<Model, Service>): this;
+    getAllReload(queryParam?: DataListParams<Sorts, Filters>): void;
+}
+export declare class TableDataProvider extends TableDataProviderInst<any> {
+    protected constructor();
+    static create<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(): TableDataProviderInst<Model, undefined, Sorts, Filters, undefined, undefined>;
+    static fromClass<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>): TableDataProviderInst<Model, undefined, Sorts, Filters, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(): TableDataProviderInst<Model, undefined, Sorts, Filters, undefined, undefined>;
+    static fromAnyParam<Model, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>): TableDataProviderInst<Model, undefined, Sorts, Filters, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: undefined, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any, Sorts = keyof Model, Filters extends keyof any = keyof Model>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): TableDataProviderInst<Model, Service, Sorts, Filters, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, Sorts = keyof Model, Filters extends keyof any = keyof Model, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): TableDataProviderInst<Model, Service, Sorts, Filters, ModelClass, ServiceClass>;
+}

package/table/api/descriptors/column.descriptor.d.ts

@@ -0,0 +1,148 @@
+import { Type } from '@angular/core';
+import { GetterFn } from '@mediusinc/mng-commons/core';
+import { FilterDescriptor } from '@mediusinc/mng-commons/filter';
+import { EnumDescriptor } from '@mediusinc/mng-commons/model';
+import { IColumnValueComponent } from '../models/column-value.model';
+import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '../models/column.model';
+import { ITableDescriptorInternal } from '../models/table.model';
+export type ColumnCurrencyOptsType<Property = string> = {
+    currencyProperty?: Property;
+    currency?: string;
+    currencyDisplay?: 'symbol' | 'code' | 'name';
+} & ColumnNumberGroupingOptsType & ColumnNumberFractionOptsType & ColumnLocaleOptsType;
+export type ColumnNumberOptsType = ColumnNumberGroupingOptsType & ColumnNumberFractionOptsType & ColumnLocaleOptsType;
+export type ColumnNumberGroupingOptsType = {
+    groupSeparator?: boolean;
+};
+export type ColumnNumberFractionOptsType = {
+    minIntegerDigits?: number;
+    minFractionDigits?: number;
+    maxFractionDigits?: number;
+};
+export type ColumnLocaleOptsType = {
+    locale?: string;
+};
+export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = ColumnModel> {
+    protected readonly _table: ITableDescriptorInternal<TableModel>;
+    protected readonly _property: string;
+    private _columnType;
+    private _columnDisplayType;
+    protected _title?: string;
+    private _displayFormat?;
+    private _locale?;
+    private _template?;
+    private _getter?;
+    private _isMultiline;
+    private _hasValueAsTooltip;
+    private _isReorderable;
+    private _isToggleable;
+    private _isVisible;
+    private _headerClassName;
+    private _className;
+    private _classNameMapFn?;
+    private _width;
+    private _minWidth;
+    private _maxWidth;
+    private _enum?;
+    private _booleanAsIcon;
+    private _booleanYes?;
+    private _booleanNo?;
+    private _currencyCode?;
+    private _currencyProperty?;
+    private _currencyDisplay?;
+    private _customComponentType?;
+    private _hasCopyToClipboard;
+    private _clipboardValueGetter?;
+    private _isLocalized;
+    private _localizationExistsProperty?;
+    constructor(table: ITableDescriptorInternal<TableModel>, property: string);
+    get columnType(): ColumnTypeEnum;
+    get columnDisplayType(): ColumnDisplayTypeEnum;
+    get title(): string | undefined;
+    get displayFormat(): string | undefined;
+    get table(): ITableDescriptorInternal<TableModel>;
+    get property(): string;
+    get headerClassName(): string;
+    get className(): string;
+    get classNameMapFn(): ((className?: string | undefined, item?: TableModel | undefined) => string) | undefined;
+    get width(): number | null;
+    get minWidth(): number | null;
+    get maxWidth(): number | null;
+    get enum(): EnumDescriptor<any> | undefined;
+    get booleanAsIcon(): boolean;
+    get booleanYes(): string | undefined;
+    get booleanNo(): string | undefined;
+    get customComponentType(): Type<IColumnValueComponent<ColumnValue, TableModel, ColumnModel>> | undefined;
+    get locale(): string | undefined;
+    get currencyCode(): string | undefined;
+    get currencyDisplay(): "symbol" | "name" | "code" | undefined;
+    get currencyProperty(): string | undefined;
+    get hasCopyToClipboard(): boolean;
+    get clipboardValueGetter(): GetterFn<ColumnValue, TableModel> | undefined;
+    get template(): string | undefined;
+    get getter(): GetterFn<ColumnValue, TableModel> | undefined;
+    get isMultiline(): boolean;
+    get hasValueAsTooltip(): boolean;
+    get isReorderable(): boolean;
+    get isToggleable(): boolean;
+    get isVisible(): boolean;
+    get isLocalized(): boolean;
+    get localizationExistsProperty(): string | undefined;
+    /**
+     * Converts column to given type with additional arguments
+     * @param type column type enum
+     * @param displayType column display type
+     * @param args any additional arguments for column (optional)
+     */
+    asType(type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum, ...args: any[]): this;
+    asNumber(opts?: ColumnNumberOptsType): this;
+    asCurrency(opts?: ColumnCurrencyOptsType<keyof ColumnModel>): this;
+    asCurrencyUnsafe(opts?: ColumnCurrencyOptsType): this;
+    asDate(displayFormat?: string): this;
+    asBoolean(yes?: string, no?: string, asIcon?: boolean): this;
+    asEnumUnsafe(enumDesc: EnumDescriptor<any>): this;
+    asCustomComponent(customComponentType: Type<IColumnValueComponent<ColumnValue, TableModel, ColumnModel>>): this;
+    asHtml(): this;
+    withClassName(className?: string, headerClassName?: string, classNameMapFn?: (className?: string, item?: TableModel) => string): this;
+    withWidth(width?: number, minWidth?: number, maxWidth?: number): this;
+    withTitle(title: string): this;
+    withFilterUnsafe(forceSimple?: boolean): FilterDescriptor<any, TableModel>;
+    withSortUnsafe(isDefault?: boolean, ascending?: boolean): this;
+    withCopyToClipboard(hasCopyToClipboard?: boolean, clipboardValueGetter?: GetterFn<ColumnValue, TableModel>): this;
+    withTemplate(template: string): this;
+    withGetter(getter?: GetterFn<ColumnValue, TableModel>): this;
+    withMultiline(isMultiline?: boolean): this;
+    withValueAsTooltip(valueAsTooltip?: boolean): this;
+    withReorderable(isReorderable?: boolean): this;
+    withToggleable(isToggleable?: boolean, isVisible?: boolean): this;
+    localized(existsProperty?: string): this;
+    copy(): ColumnDescriptor<ColumnModel, TableModel, ColumnValue>;
+    protected copyFieldsTo(obj: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): void;
+}
+export declare class ColumnDynamicDescriptor extends ColumnDescriptor<any, any> {
+    protected _title: string | undefined;
+    private _visibility;
+    constructor(table: ITableDescriptorInternal<any>, property: string);
+    get visibility(): boolean;
+    /**
+     * sets column's title and returns this column
+     * @param title title to be set
+     * @param override should column title if all ready set?
+     */
+    withTitle(title: string, override?: boolean): this;
+    /**
+     * defines automatic type and returns this column
+     * @param value
+     */
+    withAutomaticType(value: string): this;
+    /**
+     * sets visibility state for column and returns this column
+     * @param visibility
+     */
+    withVisibility(visibility: boolean): this;
+    /**
+     * creates deep copy of column dynamic descriptor
+     */
+    copy(): ColumnDynamicDescriptor;
+    toColumnDescriptor(tableDescriptor: ITableDescriptorInternal<any>): ColumnDescriptor<any, any>;
+}

package/table/api/descriptors/sort.descriptor.d.ts

@@ -0,0 +1,17 @@
+export declare class SortDescriptor<TableModel> {
+    protected readonly _property: string;
+    protected _showOnColumn: string;
+    protected _defaultIsEnabled: boolean;
+    protected _defaultIsAscending?: boolean;
+    protected _defaultOrder?: number;
+    constructor(property: string);
+    get property(): string;
+    get showOnColumn(): string;
+    get defaultIsEnabled(): boolean;
+    get defaultIsAscending(): boolean | undefined;
+    get defaultOrder(): number | undefined;
+    withShowOnColumn(property: keyof TableModel): this;
+    withShowOnColumnUnsafe(property: string): this;
+    withDefaultSort(enabled?: boolean, ascending?: boolean, order?: number): this;
+    copy(): SortDescriptor<TableModel>;
+}

package/table/api/descriptors/table.descriptor.d.ts

@@ -0,0 +1,271 @@
+import { ClassType, DataListResult, EnumConstantType, ILookupDataProvider } from '@mediusinc/mng-commons/core';
+import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor } from '@mediusinc/mng-commons/filter';
+import { EnumDescriptor, ModelDescriptor } from '@mediusinc/mng-commons/model';
+import { TableClassAttributeDef } from '../models/class-table-attribute.model';
+import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '../models/column.model';
+import { IColumnsManageInterface } from '../models/table-columns.model';
+import { ITableDescriptorInternal, TableDynamicColumnsModeEnum, TablePaginationModeEnum, TableSizeEnum } from '../models/table.model';
+import { ColumnDescriptor, ColumnDynamicDescriptor } from './column.descriptor';
+import { SortDescriptor } from './sort.descriptor';
+export declare class TableDescriptorInst<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel> implements ITableDescriptorInternal<TableModel>, IColumnsManageInterface<TableModel, Sorts, Filters> {
+    private readonly _model;
+    protected readonly _autoGenerated: boolean;
+    private _identifier?;
+    private _trackProperty?;
+    private _paginationMode?;
+    private _rowsPerPageOptions?;
+    private _defaultNumRows?;
+    protected _columns: Array<ColumnDescriptor<any, TableModel>>;
+    private _title?;
+    private _hideHeader;
+    private _loadingText?;
+    private _loadingIcon;
+    private _hasHover;
+    private _hasGridlines;
+    private _hasResizableColumns;
+    private _columnResizeMode?;
+    private _selectionColumnFrozen?;
+    private _actionColumnFrozen?;
+    private _size;
+    private _className;
+    private _headerClassName?;
+    private _rowClassName?;
+    private _rowClassNameMapFn?;
+    private _tableFullHeightOffset?;
+    private _rowHeight?;
+    private _filters;
+    private _sorts;
+    private _isLocalized;
+    private _localizationLocaleProperty?;
+    protected constructor(model: ModelDescriptor<TableModel>, autoGenerated?: boolean);
+    get identifier(): string | undefined;
+    get trackProperty(): string | undefined;
+    get paginationMode(): TablePaginationModeEnum | undefined;
+    get rowsPerPageOptions(): number[] | undefined;
+    get defaultNumRows(): number | undefined;
+    get columns(): ColumnDescriptor<any, TableModel, any>[];
+    get title(): string | undefined;
+    get hideHeader(): boolean;
+    get loadingText(): string | undefined;
+    get loadingIcon(): string | null;
+    get filters(): FilterDescriptor<any, TableModel>[];
+    get sorts(): SortDescriptor<TableModel>[];
+    get model(): ModelDescriptor<TableModel, import("@mediusinc/mng-commons/core").ClassOptType<TableModel>>;
+    get className(): string;
+    get size(): TableSizeEnum;
+    get tableFullHeightOffset(): number | undefined;
+    get rowHeight(): number | undefined;
+    get hasHover(): boolean;
+    get hasGridlines(): boolean;
+    get hasResizableColumns(): boolean;
+    get columnResizeMode(): "fit" | "expand" | undefined;
+    get rowClassName(): string | undefined;
+    get rowClassNameMapFn(): ((className?: string | undefined, item?: TableModel | undefined) => string) | undefined;
+    get selectionColumnFrozen(): boolean | undefined;
+    get actionColumnFrozen(): boolean | undefined;
+    get headerClassName(): string | undefined;
+    get isLocalized(): boolean;
+    get localizationLocaleProperty(): string | undefined;
+    /**
+     * Track property is used for the purpose of combined saving user preferences in localstorage if 2 tables have the same track properties they will share the same localstorage entry.
+     * Similarly, this property can also be used to differentiate two tables of the same model on the same url (so that they have separate entries in localstorage).
+     * @param identifier
+     */
+    withIdentifier(identifier: string): this;
+    withTrackProperty(property?: keyof TableModel): this;
+    withTrackPropertyUnsafe(property?: string): this;
+    getColumn(property: keyof TableModel): ColumnDescriptor<any, TableModel, any> | null;
+    getColumnUnsafe(property: string): ColumnDescriptor<any, TableModel, any> | 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 = unknown>(property: string): ColumnDescriptor<ColumnModel, TableModel>;
+    withColumns(...properties: (keyof TableModel)[]): this;
+    withPaginationMode(paginationMode: TablePaginationModeEnum): this;
+    withRowsPerPage(rows: number, options?: Array<number>): this;
+    withTitle(title: string): this;
+    withHideHeader(hideHeader?: boolean): this;
+    withLoading(text?: string, icon?: string | null): this;
+    /**
+     * Helper method that enables/disables reorderable property on all columns currently in the descriptor.
+     * @param columnsReorderable
+     */
+    withCurrentColumnsReorderable(columnsReorderable?: boolean): this;
+    /**
+     * Helper method that enables/disables toggleable property on all columns currently in the descriptor.
+     * @param columnsToggleable
+     */
+    withCurrentColumnsToggleable(columnsToggleable?: boolean): 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;
+    withDefaultSort(property: Sorts, ascending?: boolean, order?: number, enabled?: boolean): this;
+    withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: 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<Enum>, options?: Array<Enum>): FilterLookupEnumDescriptor<Enum, unknown>;
+    addFilterLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>): FilterLookupEnumDescriptor<Enum, unknown>;
+    addFilterFromColumn(property: Extract<Filters, keyof TableModel>, forceSimple?: boolean): FilterDescriptor<any, TableModel>;
+    withFiltersFromColumns(...properties: Extract<Filters, keyof TableModel>[]): this;
+    withFiltersFromColumnsUnsafe(...properties: string[]): this;
+    addFilterFromColumnUnsafe(property: string, forceSimple?: boolean): FilterDescriptor<any, TableModel>;
+    addFilterFromColumnDescriptorUnsafe<ColumnModel, ColumnValue>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>, forceSimple: boolean): FilterDescriptor<any, TableModel>;
+    withFilter<FilterModel>(property: Filters, filter: FilterDescriptor<FilterModel, TableModel>): this;
+    withFilterUnsafe<FilterModel>(filter: FilterDescriptor<FilterModel, TableModel>): this;
+    withClassName(className: string): this;
+    withSize(size?: TableSizeEnum): this;
+    withTableFullHeightOffset(tableFullHeightOffset: number): this;
+    withRowHeight(rowHeight: number): this;
+    withHover(hover: boolean): this;
+    withGridlines(gridlines: boolean): this;
+    /**
+     * Method that enables/disabled column resize feature with columnResizeMode on all columns.
+     * @param resizableColumns True if enabled
+     * @param columnResizeMode 'fit' or 'expand' mode
+     */
+    withColumnsResizable(resizableColumns?: boolean, columnResizeMode?: 'fit' | 'expand'): this;
+    /**
+     * Sets column to (un)frozen.
+     * @param selectionColumnFrozen True to freeze selection column, false to unfreeze it.
+     * @param actionColumnFrozen True to freeze action column, false to unfreeze it.
+     */
+    withColumnFrozen(selectionColumnFrozen?: boolean, actionColumnFrozen?: boolean): this;
+    withRowClassName(rowClassName?: string, classNameMapFn?: (className?: string, item?: TableModel) => string): this;
+    withHeaderClassName(headerClassName: string): this;
+    withLocalized(): this;
+    withLocalizationLocaleProperty(localizationLocaleProperty: string): this;
+    protected copyFieldsTo(obj: TableDescriptorInst<any, any, any>): void;
+    copy(): TableDescriptorInst<TableModel, Sorts, Filters>;
+    /**
+     * defines modified type of column
+     * DO NOT USE with enum (use withCustomEnumType)
+     * @param property column name
+     * @param columnType modified type
+     * @param args additional attributes
+     * @param columnDisplayType
+     */
+    withColumnModifiedType(property: keyof TableModel, columnType?: ColumnTypeEnum, columnDisplayType?: ColumnDisplayTypeEnum, ...args: any[]): this;
+    withColumnModifiedTypeUnsafe(property: string, columnType?: ColumnTypeEnum, columnDisplayType?: ColumnDisplayTypeEnum, ...args: any[]): this;
+    /**
+     * defines custom enum type for column
+     * @param property column name
+     * @param enumDesc Enum descriptor.
+     */
+    withColumnModifiedEnum<Property extends keyof TableModel, Enum extends NonNullable<TableModel[Property]>>(property: keyof TableModel, enumDesc?: EnumDescriptor<Enum>): this;
+    withColumnModifiedEnumUnsafe<Enum = any>(property: string, enumDesc?: EnumDescriptor<Enum>): this;
+    /**
+     * modifies column with class and lookup provider
+     * @param property column name
+     * @param lookupProvider lookupProvider for class
+     * @param optionsLabelProperty
+     * @param filterProperty
+     */
+    withModifiedLookup<ColumnLookupModel>(property: keyof TableModel, lookupProvider?: ILookupDataProvider<ColumnLookupModel>, optionsLabelProperty?: string, filterProperty?: string): this;
+    withColumnModifiedLookupUnsafe<ColumnLookupModel>(property: string, lookupProvider?: ILookupDataProvider<ColumnLookupModel>, optionsLabelProperty?: string, filterProperty?: string): this;
+    /**
+     * generates column based on attributes
+     * @param desc Table descriptor
+     * @param attribute attribute map
+     * @param column if provided, replaced by new, otherwise new is created
+     * @param args additional parameters
+     */
+    protected static upsertColumnFromAttributeDef<ColumnModel, TableModel>(desc: TableDescriptorInst<TableModel, any, any>, attribute: TableClassAttributeDef, column?: ColumnDescriptor<ColumnModel, TableModel>, ...args: any[]): ColumnDescriptor<ColumnModel, TableModel>;
+}
+export declare class TableDescriptor extends TableDescriptorInst<any> {
+    protected constructor();
+    static create<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>(idProperty?: keyof TableModel, titleProperty?: keyof TableModel, i18nBaseKey?: string | ClassType<unknown>): TableDescriptorInst<TableModel, Sorts, Filters>;
+    static fromClass<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>(type: ClassType<TableModel>, idProperty?: keyof TableModel, titleProperty?: keyof TableModel, i18nBaseKey?: ClassType<unknown> | string, isAutoGenerated?: boolean): TableDescriptorInst<TableModel, Sorts, Filters>;
+    static fromModel<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>(model: ModelDescriptor<TableModel>): TableDescriptorInst<TableModel, Sorts, Filters>;
+    /**
+     * generates descriptor based on type attribute definition
+     * @param type class type
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromClassWithAutoAttrsDef<TableModel>(type: ClassType<TableModel>, idProperty?: keyof TableModel, titleProperty?: keyof TableModel): TableDescriptorInst<TableModel>;
+    /**
+     * generates descriptor base on given attribute definition
+     * @param type class type
+     * @param attributes attributes from which descriptor is generated
+     * @param idProperty
+     * @param titleProperty
+     */
+    static fromClassWithCustomAttrsDef<TableModel>(type: ClassType<TableModel>, attributes: TableClassAttributeDef[], idProperty?: keyof TableModel, titleProperty?: keyof TableModel): TableDescriptorInst<TableModel>;
+}
+export declare class TableDynamicDescriptorInst extends TableDescriptorInst<any> {
+    private _excludedColumns;
+    private _filterColumns;
+    private _sortColumns;
+    private _sortColumnMode;
+    private _filterColumnMode;
+    protected _columns: ColumnDynamicDescriptor[];
+    protected constructor(model: ModelDescriptor<any>);
+    get columns(): ColumnDynamicDescriptor[];
+    /**
+     * defines excluded columns when generating descriptor
+     * @param excludedColumn names of excluded columns
+     */
+    withColumnsExcluded(excludedColumn: string[]): this;
+    /**
+     * defines column properties on which sort is defined or not depending on sortColumnMode
+     * @param sortOnColumns column names
+     * @param sortColumnMode INCLUDE_ONLY (default) only given columns will have sort, EXCLUDE given columns will NOT have sort
+     */
+    withColumnsSort(sortOnColumns: string[], sortColumnMode?: TableDynamicColumnsModeEnum): this;
+    /**
+     * defines column properties on which filter is defined or not depending on filterColumnMode
+     * @param filterOnColumn column names
+     * @param filterColumnMode INCLUDE_ONLY (default) only given columns will have filter, EXCLUDE given columns will NOT have filter
+     */
+    withColumnsFilter(filterOnColumn: string[], filterColumnMode?: TableDynamicColumnsModeEnum): this;
+    /**
+     * sets given type to column with given property and returns this table
+     * @param property column's property
+     * @param type custom type for column
+     * @param displayType custom column value display type
+     * @param args addition arguments for column
+     */
+    withColumnModifiedType(property: string, type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum, ...args: any[]): this;
+    /**
+     * sets title to column with given property and returns this table
+     * @param property column's property
+     * @param title column's title
+     */
+    withColumnTitle(property: string, title: string): this;
+    /**
+     * generates columns defined on table based on data fetched from api
+     * @param data data from api
+     */
+    toTableDescriptorFromData(data: DataListResult): TableDescriptorInst<any>;
+    /**
+     * adds ColumnDynamicDescriptor to this table
+     * @param property column's property
+     */
+    addColumn(property: keyof any): ColumnDynamicDescriptor;
+    removeColumn(property: keyof any): this;
+    /**
+     * creates deep copy of table dynamic descriptor
+     */
+    copy(): TableDynamicDescriptorInst;
+    toTableDescriptor(): TableDescriptorInst<any>;
+}
+export declare class TableDynamicDescriptor extends TableDynamicDescriptorInst {
+    protected constructor();
+    static create(idProperty?: string, titleProperty?: string, i18nBaseKey?: string | ClassType<any>): TableDynamicDescriptorInst;
+    static fromModel(model: ModelDescriptor<any>): TableDynamicDescriptorInst;
+}

package/table/api/helpers/class-attribute-converter.d.ts

@@ -0,0 +1,22 @@
+import { ClassAttributeDef, ClassType } from '@mediusinc/mng-commons/core';
+import { ColumnDescriptor } from '../descriptors/column.descriptor';
+import { TableClassAttributeDef } from '../models/class-table-attribute.model';
+import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '../models/column.model';
+/**
+ * converts column to number or date on value based
+ * @param column column to be transformed
+ * @param value value to check if applicable
+ */
+export declare function columnToDateNumberOrBoolean(column: ColumnDescriptor<any, any>, value: any): ColumnDescriptor<any, any>;
+/**
+ * converts string type to column type enum, default is string
+ * @param attributeType
+ */
+export declare function getColumnTypeFromClassAttributeDefType(attributeType: string): ColumnTypeEnum;
+export declare function getColumnDisplayTypeFromColumnType(columnType: ColumnTypeEnum, attributeType: string): ColumnDisplayTypeEnum;
+export declare function expandClassAttributeDefWithTableDef(attributes?: Array<ClassAttributeDef> | null): TableClassAttributeDef[];
+/**
+ * returns attributes from class type and extends to typed def with column and field enum type
+ * @param type class type
+ */
+export declare function getTableClassAttributeDef<T>(type: ClassType<T>): TableClassAttributeDef[];

package/table/api/index.d.ts

@@ -0,0 +1,11 @@
+export * from './data-providers/table.data-provider';
+export * from './descriptors/column.descriptor';
+export * from './descriptors/sort.descriptor';
+export * from './descriptors/table.descriptor';
+export * from './helpers/class-attribute-converter';
+export * from './models/class-table-attribute.model';
+export * from './models/column.model';
+export * from './models/column-value.model';
+export * from './models/table.model';
+export * from './models/table-columns.model';
+export * from './models/table-event.model';

package/table/api/models/class-table-attribute.model.d.ts

@@ -0,0 +1,8 @@
+import { ClassAttributeDef, ClassType, EnumType } from '@mediusinc/mng-commons/core';
+import { ColumnDisplayTypeEnum, ColumnTypeEnum } from './column.model';
+export interface TableClassAttributeDef extends ClassAttributeDef {
+    columnType: ColumnTypeEnum;
+    columnDisplayType: ColumnDisplayTypeEnum;
+    enumType?: EnumType;
+    classType?: ClassType<any>;
+}

package/table/api/models/column-value.model.d.ts

@@ -0,0 +1,7 @@
+import { InputSignal } from '@angular/core';
+import { ColumnDescriptor } from '../descriptors/column.descriptor';
+export interface IColumnValueComponent<Value = unknown, Item = unknown, ColumnModel = Value> {
+    value: InputSignal<Value>;
+    item: InputSignal<Item>;
+    descriptor: InputSignal<ColumnDescriptor<ColumnModel, Item, Value>>;
+}