@mediusinc/mng-commons 5.3.0-rc.3 → 5.3.0-rc.4

package/esm2022/table/api/descriptors/table.descriptor.mjs

@@ -76,12 +76,6 @@ export class TableDescriptorInst {
     get size() {
         return this._size;
     }
-    get tableFullHeightOffset() {
-        return this._tableFullHeightOffset;
-    }
-    get rowHeight() {
-        return this._rowHeight;
-    }
     get hasHover() {
         return this._hasHover;
     }
@@ -137,7 +131,7 @@ export class TableDescriptorInst {
         return this._rowExpandableComponentType;
     }
     /**
-     * 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.
+     * Identifier 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
      */
@@ -145,112 +139,236 @@ export class TableDescriptorInst {
         this._identifier = identifier;
         return this;
     }
+    /**
+     * Sets the track property (identifier of table row) for the table.
+     *
+     * @param {keyof TableModel} property - The property to track the row items by.
+     */
     withTrackProperty(property) {
         return this.withTrackPropertyUnsafe(property);
     }
+    /**
+     * Sets the track property (identifier of table row) for the table.
+     *
+     * This function is UNSAFE!
+     *
+     * @param {string} property - The property to set '_trackProperty' to.
+     */
     withTrackPropertyUnsafe(property) {
         this._trackProperty = property;
         return this;
     }
+    /**
+     * Retrieves the column descriptor for the given property.
+     *
+     * @param {keyof TableModel} property - The property for column descriptor.
+     *
+     * @return The column descriptor.
+     */
     getColumn(property) {
         return this.getColumnUnsafe(property);
     }
+    /**
+     * Retrieves the column descriptor for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param {keyof TableModel} property - The property for column descriptor.
+     *
+     * @return The column descriptor.
+     */
     getColumnUnsafe(property) {
         return this._columns.find(col => col.property === property) ?? null;
     }
+    /**
+     * Removes the column descriptor for the given property.
+     *
+     * @param {keyof TableModel} property - The property for column descriptor.
+     */
     removeColumn(property) {
         this.removeColumnUnsafe(property);
     }
+    /**
+     * Removes the column descriptor for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param {keyof TableModel} property - The property for column descriptor.
+     */
     removeColumnUnsafe(property) {
         const columnIdx = this._columns.findIndex(c => c.property === property);
         this._columns.splice(columnIdx, 1);
     }
+    /**
+     * Adds column descriptor to table columns.
+     *
+     * @param {ColumnDescriptor<ColumnModel, TableModel, ColumnValue>} column - The property for column descriptor.
+     */
     withColumn(column) {
         this._columns.push(column);
         return this;
     }
+    /**
+     * Adds a column to the table.
+     *
+     * @param {PropertyKey} property - The property key of the column in the table model.
+     *
+     * @returns The newly added column descriptor.
+     */
     addColumn(property) {
         const column = new ColumnDescriptor(property);
         this._columns.push(column);
         return column;
     }
+    /**
+     * Adds a column with enum display to the table.
+     *
+     * @param {PropertyKey} property - The property key of the table model.
+     * @param {EnumDescriptor<Enum>} enumDesc - The enum descriptor for column display.
+     * @return {ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>} - The added column descriptor.
+     */
     addColumnEnum(property, enumDesc) {
         const column = new ColumnDescriptor(property);
         column.asEnumUnsafe(enumDesc);
         this._columns.push(column);
         return column;
     }
+    /**
+     * Adds a column to the table.
+     *
+     * This function is UNSAFE!
+     *
+     * @param {string} property - The property key of the column in the table model.
+     *
+     * @returns The newly added column descriptor.
+     */
     addColumnUnsafe(property) {
         const column = new ColumnDescriptor(property);
         this._columns.push(column);
         return column;
     }
+    /**
+     * Adds one or more columns to the table model.
+     *
+     * @param properties - An array of property names to add as columns.
+     */
     withColumns(...properties) {
         properties.forEach(p => this.addColumn(p));
         return this;
     }
-    withColumnDescriptors(...descriptors) {
-        descriptors.forEach(d => this.withColumn(d));
-        return this;
-    }
+    /**
+     * Set the pagination mode for the table.
+     *
+     * @param {TablePaginationModeEnum} paginationMode - The pagination mode to set. Must be one of the values from the TablePaginationModeEnum.
+     */
     withPaginationMode(paginationMode) {
         this._paginationMode = paginationMode;
         return this;
     }
+    /**
+     * Sets the number of rows per page for a paginated display.
+     *
+     * @param {number} rows - The default number of rows to display per page.
+     * @param {Array<number>} [options] - Rows per page options to be available in table paginator.
+     */
     withRowsPerPage(rows, options) {
         this._defaultNumRows = rows;
         this._rowsPerPageOptions = options;
         return this;
     }
+    /**
+     * Sets the title for an instance of the class.
+     *
+     * @param {string} [title] - The title value to be set. It undefiend, no title will be displayed.
+     */
     withTitle(title) {
         this._title = title;
         return this;
     }
+    /**
+     * Shows/hides the header row with column titles.
+     *
+     * @param {boolean} hideHeader - A boolean value indicating whether to hide the header.
+     */
     withHideHeader(hideHeader = true) {
         this._hideHeader = hideHeader;
         return this;
     }
+    /**
+     * Adjusts loading display with custom text and/or icon.
+     *
+     * @param {string} [text] - Text to be displayed when loading indicator is shown.
+     * @param {string | null} [icon] - Icon to be used when loading indicator is shown.
+     */
     withLoading(text, icon) {
         this._loadingText = text;
         this._loadingIcon = icon === undefined ? 'pi pi-spinner' : icon;
         return this;
     }
     /**
-     * Helper method that enables/disables reorderable property on all columns currently in the descriptor.
-     * @param columnsReorderable
+     * Retrieves the sort descriptor for a given property.
+     *
+     * @param {Sorts} property - The property to retrieve the sort for.
+     *
+     * @return {SortDescriptor<TableModel> | null} The sort descriptor or null.
      */
-    withCurrentColumnsReorderable(columnsReorderable = true) {
-        for (const col of this.columns) {
-            col.withReorderable(columnsReorderable);
-        }
-        return this;
-    }
-    /**
-     * Helper method that enables/disables toggleable property on all columns currently in the descriptor.
-     * @param columnsToggleable
-     */
-    withCurrentColumnsToggleable(columnsToggleable = true) {
-        for (const col of this.columns) {
-            col.withToggleable(columnsToggleable);
-        }
-        return this;
-    }
     getSort(property) {
         return this.getSortUnsafe(property);
     }
+    /**
+     * Retrieves the sort descriptor for a given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param {Sorts} property - The property to retrieve the sort for.
+     *
+     * @return {SortDescriptor<TableModel> | null} The sort descriptor or null.
+     */
     getSortUnsafe(property) {
         return this._sorts.find(s => s.property === property) ?? null;
     }
+    /**
+     * Removes the sort for a given property.
+     *
+     * @param {Sorts} property - The property to remove the sort for.
+     */
     removeSort(property) {
         return this.removeSortUnsafe(property);
     }
+    /**
+     * Removes the sort for a given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param {Sorts} property - The property to remove the sort for.
+     */
     removeSortUnsafe(property) {
         const sortIdx = this._sorts.findIndex(c => c.property === property);
         this._sorts.splice(sortIdx, 1);
     }
+    /**
+     * Adds sort for the given property.
+     *
+     * @param property Property to add the sort for.
+     * @param isDefault If default sorting is enabled.
+     * @param ascending If default sort should be ascending.
+     *
+     * @return Created sort descriptor.
+     */
     addSort(property, isDefault = false, ascending) {
         return this.addSortUnsafe(property, isDefault, ascending);
     }
+    /**
+     * Adds sort for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Property to add the sort for.
+     * @param isDefault If default sorting is enabled.
+     * @param ascending If default sort should be ascending.
+
+     * @return Created sort descriptor.
+     */
     addSortUnsafe(property, isDefault = false, ascending) {
         const sort = new SortDescriptor(property);
         if (isDefault) {
@@ -262,16 +380,50 @@ export class TableDescriptorInst {
         this._sorts.push(sort);
         return sort;
     }
+    /**
+     * Adds sort for the given property.
+     *
+     * @param property Property to add the sort for.
+     * @param isDefault If default sorting is enabled.
+     * @param ascending If default sort should be ascending.
+     */
     withSort(property, isDefault = false, ascending) {
         return this.withSortUnsafe(property, isDefault, ascending);
     }
+    /**
+     * Adds sort for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Property to add the sort for.
+     * @param isDefault If default sorting is enabled.
+     * @param ascending If default sort should be ascending.
+     */
     withSortUnsafe(property, isDefault = false, ascending) {
         this.addSortUnsafe(property, isDefault, ascending);
         return this;
     }
+    /**
+     * Sets the default sorting for the property.
+     *
+     * @param property - The property to set default sort for.
+     * @param ascending - If the sorting should be ascending (default: true).
+     * @param order - The order for this default sort (default: 0).
+     * @param enabled - Enables/disabled the default sort.
+     */
     withDefaultSort(property, ascending, order, enabled) {
         return this.withDefaultSortUnsafe(property, ascending, order, enabled);
     }
+    /**
+     * Sets the default sorting for the property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property - The property to set default sort for.
+     * @param ascending - If the sorting should be ascending (default: true).
+     * @param order - The order for this default sort (default: 0).
+     * @param enabled - Enables/disabled the default sort.
+     */
     withDefaultSortUnsafe(property, ascending, order, enabled) {
         let sort = this._sorts.find(s => s.property === property);
         if (!sort) {
@@ -281,39 +433,115 @@ export class TableDescriptorInst {
         sort.withDefaultSort(enabled ?? true, ascending, order);
         return this;
     }
+    /**
+     * Add sorts for more properties.
+     *
+     * @param properties Properties to add the sorts for.
+     */
     withSorts(...properties) {
         return this.withSortsUnsafe(...properties);
     }
+    /**
+     * Add sorts for more properties.
+     *
+     * This function is UNSAFE!
+     *
+     * @param properties Properties to add the sorts for.
+     */
     withSortsUnsafe(...properties) {
         properties.forEach(p => {
             this._sorts.push(new SortDescriptor(p));
         });
         return this;
     }
+    /**
+     * Gets filter descriptor for given property.
+     *
+     * @param property Filter property
+     *
+     * @return Filter descriptor for property or null if not exists.
+     */
     getFilter(property) {
         return this.getFilterUnsafe(property);
     }
+    /**
+     * Gets filter descriptor for given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Filter property
+     *
+     * @return Filter descriptor for property or null if not exists.
+     */
     getFilterUnsafe(property) {
         return this._filters.find(s => s.property === property) ?? null;
     }
+    /**
+     * Removes filter descriptor for given property.
+     *
+     * @param property Filter property
+     */
     removeFilter(property) {
         return this.removeFilterUnsafe(property);
     }
+    /**
+     * Removes filter descriptor for given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Filter property
+     */
     removeFilterUnsafe(property) {
         const filterIdx = this._filters.findIndex(c => c.property === property);
         this._filters.splice(filterIdx, 1);
     }
+    /**
+     * Creates filter descriptor for the given property.
+     *
+     * @param property Filter property.
+     *
+     * @return Created filter descriptor.
+     */
     addFilter(property) {
         return this.addFilterUnsafe(property);
     }
+    /**
+     * Creates filter descriptor for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Filter property.
+     *
+     * @return Created filter descriptor.
+     */
     addFilterUnsafe(property) {
         const filter = new FilterDescriptor(property);
         this._filters.push(filter);
         return filter;
     }
+    /**
+     * Creates filter lookup descriptor for the given property.
+     *
+     * @param property Filter property.
+     * @param provider Lookup provider.
+     * @param optionsValueProperty Property on lookup provider's item (FilterModel) that will be used as filter value.
+     *
+     * @return Created filter lookup descriptor.
+     */
     addFilterLookup(property, provider, optionsValueProperty) {
         return this.addFilterLookupUnsafe(property, provider, optionsValueProperty);
     }
+    /**
+     * Creates filter lookup descriptor for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Filter property.
+     * @param provider Lookup provider.
+     * @param optionsValueProperty Property on lookup provider's item (FilterModel) that will be used as filter value.
+     *
+     * @return Created filter lookup descriptor.
+     */
     addFilterLookupUnsafe(property, provider, optionsValueProperty) {
         const filter = new FilterLookupDescriptor(property, {
             dataProvider: provider,
@@ -322,26 +550,86 @@ export class TableDescriptorInst {
         this._filters.push(filter);
         return filter;
     }
+    /**
+     * Creates filter lookup enum descriptor for the given property.
+     *
+     * @param property Filter property.
+     * @param enumDesc Descriptor for enum.
+     * @param options Optional options of enum values to be available to filter by.
+     *
+     * @return Created filter lookup enum descriptor.
+     */
     addFilterLookupEnum(property, enumDesc, options) {
         return this.addFilterLookupEnumUnsafe(property, enumDesc, options);
     }
+    /**
+     * Creates filter lookup enum descriptor for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Filter property.
+     * @param enumDesc Descriptor for enum.
+     * @param options Optional options of enum values to be available to filter by.
+     *
+     * @return Created filter lookup enum descriptor.
+     */
     addFilterLookupEnumUnsafe(property, enumDesc, options) {
         const filter = new FilterLookupEnumDescriptor(property, enumDesc, options);
         this._filters.push(filter);
         return filter;
     }
+    /**
+     * Creates filter descriptor from column. The column must exist on table descriptor.
+     *
+     * @param property Column property to add filter for.
+     * @param displayType Optional display type setting.
+     * @param forceSimple Forces simple creation of filter (no lookup or lookup enum filters).
+     *
+     * @throws {CommonsInternalError} If column for property doesn't exist.
+     *
+     * @return Created filter descriptor
+     */
     addFilterFromColumn(property, displayType, forceSimple = false) {
         return this.addFilterFromColumnUnsafe(property, displayType, forceSimple);
     }
+    /**
+     * Creates filter descriptors from columns. The columns must exist on table descriptor.
+     *
+     * @param properties Column properties to add filters for.
+     *
+     * @throws {CommonsInternalError} If column for property doesn't exist.
+     */
     withFiltersFromColumns(...properties) {
         return this.withFiltersFromColumnsUnsafe(...properties);
     }
+    /**
+     * Creates filter descriptors from columns. The columns must exist on table descriptor.
+     *
+     * This function is UNSAFE!
+     *
+     * @param properties Column properties to add filters for.
+     *
+     * @throws {CommonsInternalError} If column for property doesn't exist.
+     */
     withFiltersFromColumnsUnsafe(...properties) {
         properties.forEach(p => {
             this.addFilterFromColumnUnsafe(p);
         });
         return this;
     }
+    /**
+     * Creates filter descriptor from column. The column must exist on table descriptor.
+     *
+     * This function is UNSAFE!
+     *
+     * @param property Column property to add filter for.
+     * @param displayType Optional display type setting.
+     * @param forceSimple Forces simple creation of filter (no lookup or lookup enum filters).
+     *
+     * @throws {CommonsInternalError} If column for property doesn't exist.
+     *
+     * @return Created filter descriptor
+     */
     addFilterFromColumnUnsafe(property, displayType, forceSimple = false) {
         const column = this.getColumnUnsafe(property);
         if (!column) {
@@ -352,6 +640,18 @@ export class TableDescriptorInst {
             filter.withDisplayType(displayType);
         return filter;
     }
+    /**
+     * Creates filter descriptor from provided column descriptor.
+     *
+     * This function is UNSAFE!
+     *
+     * @param column Column descriptor.
+     * @param forceSimple Forces simple creation of filter (no lookup or lookup enum filters).
+     *
+     * @throws {CommonsInternalError} If column for property doesn't exist.
+     *
+     * @return Created filter descriptor
+     */
     addFilterFromColumnDescriptorUnsafe(column, forceSimple = false) {
         let filterDescriptor = new FilterDescriptor(column.property);
         let filterType;
@@ -387,42 +687,90 @@ export class TableDescriptorInst {
         this._filters.push(filterDescriptor);
         return filterDescriptor;
     }
+    /**
+     * Adds filter descriptor for the given property.
+     *
+     * @param property Filter property.
+     * @param filter Descriptor for property.
+     */
     withFilter(property, filter) {
         if (filter.property !== property) {
             throw new CommonsInternalError(`Filter property "${property}" and Filter descriptor property "${filter.property}" do not match.`);
         }
         return this.withFilterUnsafe(filter);
     }
+    /**
+     * Adds filter descriptor for the given property.
+     *
+     * This function is UNSAFE!
+     *
+     * @param filter Descriptor for property.
+     */
     withFilterUnsafe(filter) {
         this._filters.push(filter);
         return this;
     }
+    /**
+     * Sets classes for table component.
+     *
+     * @param className Class names.
+     */
     withClassName(className) {
         this._className = className;
         return this;
     }
+    /**
+     * Sets table sizing.
+     *
+     * @param size Table size.
+     */
     withSize(size = TableSizeEnum.Normal) {
         this._size = size;
         return this;
     }
-    withTableFullHeightOffset(tableFullHeightOffset) {
-        this._tableFullHeightOffset = tableFullHeightOffset;
+    /**
+     * Enables hover effect on table rows.
+     *
+     * @param hover Enables/disables the hover.
+     */
+    withHover(hover = true) {
+        this._hasHover = hover;
         return this;
     }
-    withRowHeight(rowHeight) {
-        this._rowHeight = rowHeight;
+    /**
+     * Enables gridlines on table.
+     *
+     * @param gridlines Enables/disables the gridlines.
+     */
+    withGridlines(gridlines = true) {
+        this._hasGridlines = gridlines;
         return this;
     }
-    withHover(hover) {
-        this._hasHover = hover;
+    /**
+     * Enables/disables reorderable property on all columns currently in the descriptor.
+     *
+     * @param {boolean} [columnsReorderable] - Boolean flag to set reordering on columns to.
+     */
+    withCurrentColumnsReorderable(columnsReorderable = true) {
+        for (const col of this.columns) {
+            col.withReorderable(columnsReorderable);
+        }
         return this;
     }
-    withGridlines(gridlines) {
-        this._hasGridlines = gridlines;
+    /**
+     * Enables/disables toggleable property on all columns currently in the descriptor.
+     *
+     * @param {boolean} [columnsToggleable] - Boolean flag to set toggleable on columns to.
+     */
+    withCurrentColumnsToggleable(columnsToggleable = true) {
+        for (const col of this.columns) {
+            col.withToggleable(columnsToggleable);
+        }
         return this;
     }
     /**
-     * Method that enables/disabled column resize feature with columnResizeMode on all columns.
+     * Enables/disabled column resize feature with columnResizeMode on all columns.
+     *
      * @param resizableColumns True if enabled
      * @param columnResizeMode 'fit' or 'expand' mode
      */
@@ -433,6 +781,7 @@ export class TableDescriptorInst {
     }
     /**
      * 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.
      */
@@ -441,24 +790,50 @@ export class TableDescriptorInst {
         this._actionColumnFrozen = actionColumnFrozen;
         return this;
     }
+    /**
+     * Sets the class name for rows in the table.
+     *
+     * @param {string} rowClassName - The CSS class name to be applied to each row.
+     * @param {function} [classNameMapFn] - Optional function to map the class name dynamically based on row's item and current class name.
+     */
     withRowClassName(rowClassName, classNameMapFn) {
         this._rowClassName = rowClassName;
         this._rowClassNameMapFn = classNameMapFn;
         return this;
     }
+    /**
+     * Sets header row class name.
+     *
+     * @param headerClassName Class name.
+     */
     withHeaderClassName(headerClassName) {
         this._headerClassName = headerClassName;
         return this;
     }
+    /**
+     * Enables localization of the table.
+     */
     withLocalized() {
         this._isLocalized = true;
         return this;
     }
-    withLocalizationLocaleProperty(localizationLocaleProperty) {
+    /**
+     * Sets locale property for localization.
+     *
+     * @param property Locale property
+     */
+    withLocalizationLocaleProperty(property) {
         this._isLocalized = true;
-        this._localizationLocaleProperty = localizationLocaleProperty;
+        this._localizationLocaleProperty = property;
         return this;
     }
+    /**
+     * Enables row expanding.
+     *
+     * @param property Property to check if row can be expanded.
+     * @param colSpan set custom row span for expanded row.
+     * @param componentType Component to be displayed on row expand.
+     */
     withRowExpandable(property, colSpan, componentType) {
         this._rowExpandable = true;
         if (property) {
@@ -472,6 +847,11 @@ export class TableDescriptorInst {
         }
         return this;
     }
+    /**
+     * Enables row reordering.
+     *
+     * @param reordable Enables/disables feature.
+     */
     withRowReorderable(reordable = true) {
         this._rowReorderable = reordable;
         return this;
@@ -484,8 +864,6 @@ export class TableDescriptorInst {
         obj._sorts = this._sorts.map(s => s.copy());
         obj._className = this._className;
         obj._size = this._size;
-        obj._tableFullHeightOffset = this._tableFullHeightOffset;
-        obj._rowHeight = this._rowHeight;
         obj._hasHover = this._hasHover;
         obj._hasGridlines = this._hasGridlines;
         obj._hasResizableColumns = this._hasResizableColumns;
@@ -502,6 +880,9 @@ export class TableDescriptorInst {
         obj._rowExpandableComponentType = this._rowExpandableComponentType;
         obj._rowReorderable = this._rowReorderable;
     }
+    /**
+     * Copies current descriptor to a new instance.
+     */
     copy() {
         const descriptor = new TableDescriptorInst(this.model.copy());
         this.copyFieldsTo(descriptor);
@@ -655,4 +1036,4 @@ export class TableDynamicDescriptorInst extends TableDescriptorInst {
         return descriptor;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.descriptor.js","sourceRoot":"","sources":["../../../../../table/api/src/descriptors/table.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\n\nimport {CommonsInternalError, DataListResult, EnumConstantType, ILookupDataProvider, ITableDescriptor, flattenObjectKeys} from '@mediusinc/mng-commons/core';\nimport {FilterDescriptor, FilterDisplayTypeEnum, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterTypeEnum} from '@mediusinc/mng-commons/filter';\nimport {EnumDescriptor, ModelDescriptor} from '@mediusinc/mng-commons/model';\n\nimport {columnToDateNumberOrBoolean} from '../helpers/class-attribute-converter';\nimport {ColumnDisplayTypeEnum, ColumnTypeEnum} from '../models/column.model';\nimport {IRowExpandableComponent} from '../models/row-expandable-component.model';\nimport {IColumnsManageInterface} from '../models/table-columns.model';\nimport {TableDynamicColumnsModeEnum, TablePaginationModeEnum, TableSizeEnum} from '../models/table.model';\nimport {ColumnDescriptor, ColumnDynamicDescriptor} from './column.descriptor';\nimport {SortDescriptor} from './sort.descriptor';\n\nexport class TableDescriptorInst<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>\n    implements ITableDescriptor<TableModel, Sorts, Filters>, IColumnsManageInterface<TableModel, Sorts, Filters>\n{\n    private readonly _model: ModelDescriptor<TableModel>;\n    protected readonly _autoGenerated;\n\n    private _identifier?: string;\n    private _trackProperty?: string;\n    private _paginationMode?: TablePaginationModeEnum;\n    private _rowsPerPageOptions?: number[];\n    private _defaultNumRows?: number;\n    protected _columns: Array<ColumnDescriptor<any, TableModel>> = [];\n    private _title?: string;\n    private _hideHeader = false;\n    private _loadingText?: string;\n    private _loadingIcon: string | null = 'pi pi-spinner';\n\n    // extra\n    private _hasHover = true;\n    private _hasGridlines = false;\n    private _hasResizableColumns = false;\n    private _columnResizeMode?: 'fit' | 'expand';\n\n    // special columns\n    private _selectionColumnFrozen?: boolean;\n    private _actionColumnFrozen?: boolean;\n\n    // styling\n    private _size: TableSizeEnum = TableSizeEnum.Large;\n    private _className = '';\n    private _headerClassName?: string;\n    private _rowClassName?: string;\n    private _rowClassNameMapFn?: (className?: string, item?: TableModel) => string;\n    private _tableFullHeightOffset?: number;\n    private _rowHeight?: number;\n\n    // filters&sorts\n    private _filters: FilterDescriptor<any, TableModel>[] = [];\n    private _sorts: SortDescriptor<TableModel>[] = [];\n\n    // localization\n    private _isLocalized = false;\n    private _localizationLocaleProperty?: string;\n\n    // row expand\n    private _rowExpandable = false;\n    private _rowExpandableColSpan = 100;\n    private _rowExpandableProperty?: string;\n    private _rowExpandableComponentType?: Type<IRowExpandableComponent<TableModel>>;\n\n    // row reorder\n    private _rowReorderable = false;\n\n    public constructor(model: ModelDescriptor<TableModel>, autoGenerated = false) {\n        this._model = model;\n        this._trackProperty = this._model.idProperty;\n        this._autoGenerated = autoGenerated;\n    }\n\n    public get identifier() {\n        return this._identifier;\n    }\n\n    public get trackProperty() {\n        return this._trackProperty;\n    }\n\n    public get paginationMode() {\n        return this._paginationMode;\n    }\n\n    get rowsPerPageOptions() {\n        return this._rowsPerPageOptions;\n    }\n\n    get defaultNumRows() {\n        return this._defaultNumRows;\n    }\n\n    public get columns() {\n        return this._columns;\n    }\n\n    public get title() {\n        return this._title;\n    }\n\n    public get hideHeader() {\n        return this._hideHeader;\n    }\n\n    public get loadingText() {\n        return this._loadingText;\n    }\n\n    public get loadingIcon() {\n        return this._loadingIcon;\n    }\n\n    public get filters() {\n        return this._filters;\n    }\n\n    public get sorts() {\n        return this._sorts;\n    }\n\n    public get model() {\n        return this._model;\n    }\n\n    public get className() {\n        return this._className;\n    }\n\n    public get size() {\n        return this._size;\n    }\n\n    public get tableFullHeightOffset() {\n        return this._tableFullHeightOffset;\n    }\n\n    public get rowHeight() {\n        return this._rowHeight;\n    }\n\n    public get hasHover() {\n        return this._hasHover;\n    }\n\n    public get hasGridlines() {\n        return this._hasGridlines;\n    }\n\n    public get hasResizableColumns() {\n        return this._hasResizableColumns;\n    }\n\n    public get columnResizeMode() {\n        return this._columnResizeMode;\n    }\n\n    public get rowClassName() {\n        return this._rowClassName;\n    }\n\n    public get rowClassNameMapFn() {\n        return this._rowClassNameMapFn;\n    }\n\n    public get selectionColumnFrozen() {\n        return this._selectionColumnFrozen;\n    }\n\n    public get actionColumnFrozen() {\n        return this._actionColumnFrozen;\n    }\n\n    public get headerClassName() {\n        return this._headerClassName;\n    }\n\n    public get isLocalized() {\n        return this._isLocalized;\n    }\n\n    public get localizationLocaleProperty() {\n        return this._localizationLocaleProperty;\n    }\n\n    public get rowReorderable() {\n        return this._rowReorderable;\n    }\n\n    public get rowExpandable() {\n        return this._rowExpandable;\n    }\n\n    public get rowExpandableColSpan() {\n        return this._rowExpandableColSpan;\n    }\n\n    /**\n     * This table model property tells us if the specific row should be expandable or not based on row item value\n     */\n    public get rowExpandableProperty() {\n        return this._rowExpandableProperty;\n    }\n\n    /**\n     * This property is used to define the type of the custom component that will be used to render the expanded row.\n     */\n    public get rowExpandableComponentType() {\n        return this._rowExpandableComponentType;\n    }\n\n    /**\n     * 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.\n     * 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).\n     * @param identifier\n     */\n    public withIdentifier(identifier: string): this {\n        this._identifier = identifier;\n        return this;\n    }\n\n    public withTrackProperty(property?: keyof TableModel): this {\n        return this.withTrackPropertyUnsafe(property as string);\n    }\n\n    public withTrackPropertyUnsafe(property?: string): this {\n        this._trackProperty = property;\n        return this;\n    }\n\n    public getColumn(property: keyof TableModel) {\n        return this.getColumnUnsafe(property as string);\n    }\n\n    public getColumnUnsafe(property: string) {\n        return this._columns.find(col => col.property === property) ?? null;\n    }\n\n    public removeColumn(property: keyof TableModel): void {\n        this.removeColumnUnsafe(property as string);\n    }\n\n    public removeColumnUnsafe(property: string): void {\n        const columnIdx = this._columns.findIndex(c => c.property === property);\n        this._columns.splice(columnIdx, 1);\n    }\n\n    public withColumn<ColumnModel, ColumnValue = ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): this {\n        this._columns.push(column);\n        return this;\n    }\n\n    public addColumn<PropertyKey extends keyof TableModel>(property: PropertyKey) {\n        const column = new ColumnDescriptor<NonNullable<TableModel[PropertyKey]>, TableModel, TableModel[PropertyKey]>(property as string);\n        this._columns.push(column);\n        return column;\n    }\n\n    public addColumnEnum<PropertyKey extends keyof TableModel, Enum extends NonNullable<TableModel[PropertyKey]>>(property: PropertyKey, enumDesc: EnumDescriptor<Enum>) {\n        const column = new ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>(property as string);\n        column.asEnumUnsafe(enumDesc);\n        this._columns.push(column);\n        return column;\n    }\n\n    public addColumnUnsafe<ColumnModel = unknown>(property: string): ColumnDescriptor<ColumnModel, TableModel> {\n        const column = new ColumnDescriptor<ColumnModel, TableModel>(property);\n        this._columns.push(column);\n        return column;\n    }\n\n    public withColumns(...properties: (keyof TableModel)[]): this {\n        properties.forEach(p => this.addColumn(p));\n        return this;\n    }\n\n    public withColumnDescriptors(...descriptors: ColumnDescriptor<any, TableModel>[]): this {\n        descriptors.forEach(d => this.withColumn(d));\n        return this;\n    }\n\n    public withPaginationMode(paginationMode: TablePaginationModeEnum): this {\n        this._paginationMode = paginationMode;\n        return this;\n    }\n\n    public withRowsPerPage(rows: number, options?: Array<number>) {\n        this._defaultNumRows = rows;\n        this._rowsPerPageOptions = options;\n        return this;\n    }\n\n    public withTitle(title: string | undefined): this {\n        this._title = title;\n\n        return this;\n    }\n\n    public withHideHeader(hideHeader = true) {\n        this._hideHeader = hideHeader;\n        return this;\n    }\n\n    public withLoading(text?: string, icon?: string | null): this {\n        this._loadingText = text;\n        this._loadingIcon = icon === undefined ? 'pi pi-spinner' : icon;\n        return this;\n    }\n\n    /**\n     * Helper method that enables/disables reorderable property on all columns currently in the descriptor.\n     * @param columnsReorderable\n     */\n    public withCurrentColumnsReorderable(columnsReorderable = true): this {\n        for (const col of this.columns) {\n            col.withReorderable(columnsReorderable);\n        }\n        return this;\n    }\n\n    /**\n     * Helper method that enables/disables toggleable property on all columns currently in the descriptor.\n     * @param columnsToggleable\n     */\n    public withCurrentColumnsToggleable(columnsToggleable = true): this {\n        for (const col of this.columns) {\n            col.withToggleable(columnsToggleable);\n        }\n        return this;\n    }\n\n    public getSort(property: Sorts) {\n        return this.getSortUnsafe(property as string);\n    }\n\n    public getSortUnsafe(property: string) {\n        return this._sorts.find(s => s.property === property) ?? null;\n    }\n\n    public removeSort(property: Sorts) {\n        return this.removeSortUnsafe(property as string);\n    }\n\n    public removeSortUnsafe(property: string) {\n        const sortIdx = this._sorts.findIndex(c => c.property === property);\n        this._sorts.splice(sortIdx, 1);\n    }\n\n    public addSort(property: Sorts, isDefault = false, ascending?: boolean) {\n        return this.addSortUnsafe(property as string, isDefault, ascending);\n    }\n\n    public addSortUnsafe(property: string, isDefault = false, ascending?: boolean) {\n        const sort = new SortDescriptor<TableModel>(property);\n        if (isDefault) {\n            const defaultOrderMax = this._sorts\n                .filter(s => s.defaultIsEnabled)\n                .reduce((acc, s) => (s.defaultOrder !== undefined && s.defaultOrder > acc ? s.defaultOrder : acc), -1);\n            sort.withDefaultSort(true, ascending, defaultOrderMax + 1);\n        }\n        this._sorts.push(sort);\n        return sort;\n    }\n\n    public withSort(property: Sorts, isDefault = false, ascending?: boolean): this {\n        return this.withSortUnsafe(property as string, isDefault, ascending);\n    }\n\n    public withSortUnsafe(property: string, isDefault = false, ascending?: boolean): this {\n        this.addSortUnsafe(property, isDefault, ascending);\n        return this;\n    }\n\n    public withDefaultSort(property: Sorts, ascending?: boolean, order?: number, enabled?: boolean): this {\n        return this.withDefaultSortUnsafe(property as string, ascending, order, enabled);\n    }\n\n    public withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: boolean): this {\n        let sort = this._sorts.find(s => s.property === property);\n        if (!sort) {\n            sort = new SortDescriptor(property);\n            this._sorts.push(sort);\n        }\n        sort.withDefaultSort(enabled ?? true, ascending, order);\n        return this;\n    }\n\n    public withSorts(...properties: Sorts[]): this {\n        return this.withSortsUnsafe(...(properties as string[]));\n    }\n\n    public withSortsUnsafe(...properties: string[]): this {\n        properties.forEach(p => {\n            this._sorts.push(new SortDescriptor(p));\n        });\n        return this;\n    }\n\n    public getFilter(property: Filters) {\n        return this.getFilterUnsafe(property as string);\n    }\n\n    public getFilterUnsafe(property: string) {\n        return this._filters.find(s => s.property === property) ?? null;\n    }\n\n    public removeFilter(property: Filters) {\n        return this.removeFilterUnsafe(property as string);\n    }\n\n    public removeFilterUnsafe(property: string) {\n        const filterIdx = this._filters.findIndex(c => c.property === property);\n        this._filters.splice(filterIdx, 1);\n    }\n\n    public addFilter<FilterModel = Filters extends keyof TableModel ? TableModel[Filters] : never>(property: Filters) {\n        return this.addFilterUnsafe<FilterModel>(property as string);\n    }\n\n    public addFilterUnsafe<FilterModel>(property: string) {\n        const filter = new FilterDescriptor<FilterModel, TableModel>(property);\n        this._filters.push(filter);\n        return filter;\n    }\n\n    public addFilterLookup<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : never, Service = undefined>(\n        property: Filters,\n        provider?: ILookupDataProvider<FilterModel, Service>,\n        optionsValueProperty?: keyof FilterModel\n    ) {\n        return this.addFilterLookupUnsafe(property as string, provider, optionsValueProperty as string);\n    }\n\n    public addFilterLookupUnsafe<FilterModel, Service = undefined>(property: string, provider?: ILookupDataProvider<FilterModel, Service>, optionsValueProperty?: string) {\n        const filter = new FilterLookupDescriptor<FilterModel, TableModel, Service>(property, {\n            dataProvider: provider,\n            optionsValueProperty: optionsValueProperty\n        });\n        this._filters.push(filter);\n        return filter;\n    }\n\n    public addFilterLookupEnum<Enum>(property: Filters, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>) {\n        return this.addFilterLookupEnumUnsafe<Enum>(property as string, enumDesc, options);\n    }\n\n    public addFilterLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>) {\n        const filter = new FilterLookupEnumDescriptor(property, enumDesc, options);\n        this._filters.push(filter);\n        return filter;\n    }\n\n    public addFilterFromColumn(property: Extract<Filters, keyof TableModel>, displayType?: FilterDisplayTypeEnum, forceSimple = false) {\n        return this.addFilterFromColumnUnsafe(property as string, displayType, forceSimple);\n    }\n\n    public withFiltersFromColumns(...properties: Extract<Filters, keyof TableModel>[]): this {\n        return this.withFiltersFromColumnsUnsafe(...(properties as string[]));\n    }\n\n    public withFiltersFromColumnsUnsafe(...properties: string[]): this {\n        properties.forEach(p => {\n            this.addFilterFromColumnUnsafe(p);\n        });\n        return this;\n    }\n\n    public addFilterFromColumnUnsafe(property: string, displayType?: FilterDisplayTypeEnum, forceSimple = false) {\n        const column = this.getColumnUnsafe(property);\n        if (!column) {\n            throw new CommonsInternalError(`No column found for filter property \"${property}\"`);\n        }\n        const filter = this.addFilterFromColumnDescriptorUnsafe(column, forceSimple);\n        if (displayType != null) filter.withDisplayType(displayType);\n        return filter;\n    }\n\n    public addFilterFromColumnDescriptorUnsafe<ColumnModel, ColumnValue>(\n        column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>,\n        forceSimple = false\n    ): FilterDescriptor<any, TableModel> {\n        let filterDescriptor = new FilterDescriptor<any, TableModel>(column.property);\n        let filterType: FilterTypeEnum;\n\n        switch (column.columnType) {\n            case ColumnTypeEnum.Number:\n                filterType = FilterTypeEnum.Number;\n                break;\n            case ColumnTypeEnum.Boolean:\n                filterType = FilterTypeEnum.Boolean;\n                break;\n            case ColumnTypeEnum.Date:\n                filterType = FilterTypeEnum.Date;\n                break;\n            case ColumnTypeEnum.Enum:\n                if (!forceSimple && column.enum) {\n                    filterDescriptor = new FilterLookupEnumDescriptor(column.property, column.enum);\n                    filterType = FilterTypeEnum.LookupEnum;\n                } else {\n                    filterType = FilterTypeEnum.String;\n                }\n                break;\n            case ColumnTypeEnum.String:\n            case ColumnTypeEnum.Custom:\n            default:\n                filterType = FilterTypeEnum.String;\n                break;\n        }\n\n        filterDescriptor.asFilterType(filterType);\n        if ((filterType === FilterTypeEnum.Number || filterType === FilterTypeEnum.Date) && column.displayFormat) {\n            filterDescriptor.withDisplayFormat(column.displayFormat, true);\n        }\n\n        this._filters.push(filterDescriptor);\n\n        return filterDescriptor;\n    }\n\n    public withFilter<FilterModel>(property: Filters, filter: FilterDescriptor<FilterModel, TableModel>): this {\n        if (filter.property !== property) {\n            throw new CommonsInternalError(`Filter property \"${property}\" and Filter descriptor property \"${filter.property}\" do not match.`);\n        }\n        return this.withFilterUnsafe<FilterModel>(filter);\n    }\n\n    public withFilterUnsafe<FilterModel>(filter: FilterDescriptor<FilterModel, TableModel>): this {\n        this._filters.push(filter);\n        return this;\n    }\n\n    public withClassName(className: string): this {\n        this._className = className;\n        return this;\n    }\n\n    public withSize(size: TableSizeEnum = TableSizeEnum.Normal): this {\n        this._size = size;\n        return this;\n    }\n\n    public withTableFullHeightOffset(tableFullHeightOffset: number): this {\n        this._tableFullHeightOffset = tableFullHeightOffset;\n        return this;\n    }\n\n    public withRowHeight(rowHeight: number): this {\n        this._rowHeight = rowHeight;\n        return this;\n    }\n\n    public withHover(hover: boolean): this {\n        this._hasHover = hover;\n        return this;\n    }\n\n    public withGridlines(gridlines: boolean): this {\n        this._hasGridlines = gridlines;\n        return this;\n    }\n\n    /**\n     * Method that enables/disabled column resize feature with columnResizeMode on all columns.\n     * @param resizableColumns True if enabled\n     * @param columnResizeMode 'fit' or 'expand' mode\n     */\n    public withColumnsResizable(resizableColumns = true, columnResizeMode: 'fit' | 'expand' = 'fit'): this {\n        this._hasResizableColumns = resizableColumns;\n        this._columnResizeMode = columnResizeMode;\n        return this;\n    }\n\n    /**\n     * Sets column to (un)frozen.\n     * @param selectionColumnFrozen True to freeze selection column, false to unfreeze it.\n     * @param actionColumnFrozen True to freeze action column, false to unfreeze it.\n     */\n    public withColumnFrozen(selectionColumnFrozen?: boolean, actionColumnFrozen?: boolean): this {\n        this._selectionColumnFrozen = selectionColumnFrozen;\n        this._actionColumnFrozen = actionColumnFrozen;\n        return this;\n    }\n\n    public withRowClassName(rowClassName?: string, classNameMapFn?: (className?: string, item?: TableModel) => string): this {\n        this._rowClassName = rowClassName;\n        this._rowClassNameMapFn = classNameMapFn;\n        return this;\n    }\n\n    public withHeaderClassName(headerClassName: string): this {\n        this._headerClassName = headerClassName;\n        return this;\n    }\n\n    public withLocalized(): this {\n        this._isLocalized = true;\n        return this;\n    }\n\n    public withLocalizationLocaleProperty(localizationLocaleProperty: string): this {\n        this._isLocalized = true;\n        this._localizationLocaleProperty = localizationLocaleProperty;\n        return this;\n    }\n\n    public withRowExpandable(property?: keyof TableModel, colSpan?: number, componentType?: Type<IRowExpandableComponent<TableModel>>): this {\n        this._rowExpandable = true;\n        if (property) {\n            this._rowExpandableProperty = property as string;\n        }\n        if (colSpan) {\n            this._rowExpandableColSpan = colSpan;\n        }\n        if (componentType) {\n            this._rowExpandableComponentType = componentType;\n        }\n        return this;\n    }\n\n    withRowReorderable(reordable = true) {\n        this._rowReorderable = reordable;\n        return this;\n    }\n\n    protected copyFieldsTo(obj: TableDescriptorInst<any, any, any>) {\n        obj._title = this._title;\n        obj._hideHeader = this._hideHeader;\n        obj._trackProperty = this._trackProperty;\n        obj._filters = this._filters.map(f => f.copy());\n        obj._sorts = this._sorts.map(s => s.copy());\n        obj._className = this._className;\n        obj._size = this._size;\n        obj._tableFullHeightOffset = this._tableFullHeightOffset;\n        obj._rowHeight = this._rowHeight;\n        obj._hasHover = this._hasHover;\n        obj._hasGridlines = this._hasGridlines;\n        obj._hasResizableColumns = this._hasResizableColumns;\n        obj._columnResizeMode = this._columnResizeMode;\n        obj._actionColumnFrozen = this._actionColumnFrozen;\n        obj._selectionColumnFrozen = this._selectionColumnFrozen;\n        obj._isLocalized = this._isLocalized;\n        obj._localizationLocaleProperty = this._localizationLocaleProperty;\n        obj._paginationMode = this._paginationMode;\n        obj._rowsPerPageOptions = this._rowsPerPageOptions;\n        obj._rowExpandable = this._rowExpandable;\n        obj._rowExpandableColSpan = this._rowExpandableColSpan;\n        obj._rowExpandableProperty = this._rowExpandableProperty;\n        obj._rowExpandableComponentType = this._rowExpandableComponentType;\n        obj._rowReorderable = this._rowReorderable;\n    }\n\n    public copy(): TableDescriptorInst<TableModel, Sorts, Filters> {\n        const descriptor = new TableDescriptorInst<TableModel, Sorts, Filters>(this.model.copy());\n        this.copyFieldsTo(descriptor);\n        descriptor._columns = this.columns.map(c => c.copy());\n        return descriptor;\n    }\n}\n\nexport class TableDynamicDescriptorInst extends TableDescriptorInst<any> {\n    private _excludedColumns: Array<string> = [];\n    private _filterColumns: Array<string> = [];\n    private _sortColumns: Array<string> = [];\n    private _sortColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;\n    private _filterColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;\n\n    protected override _columns: ColumnDynamicDescriptor[] = [];\n\n    public constructor(model: ModelDescriptor<any>) {\n        super(model);\n\n        if (typeof model.titleProperty === 'string') {\n            this.withTitle(model.titleProperty);\n        }\n    }\n\n    public override get columns() {\n        return this._columns;\n    }\n\n    /**\n     * defines excluded columns when generating descriptor\n     * @param excludedColumn names of excluded columns\n     */\n    public withColumnsExcluded(excludedColumn: string[]): this {\n        this._excludedColumns = excludedColumn;\n        return this;\n    }\n\n    /**\n     * defines column properties on which sort is defined or not depending on sortColumnMode\n     * @param sortOnColumns column names\n     * @param sortColumnMode INCLUDE_ONLY (default) only given columns will have sort, EXCLUDE given columns will NOT have sort\n     */\n    public withColumnsSort(sortOnColumns: string[], sortColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY): this {\n        this._sortColumnMode = sortColumnMode;\n        this._sortColumns = sortOnColumns;\n        return this;\n    }\n\n    /**\n     * defines column properties on which filter is defined or not depending on filterColumnMode\n     * @param filterOnColumn column names\n     * @param filterColumnMode INCLUDE_ONLY (default) only given columns will have filter, EXCLUDE given columns will NOT have filter\n     */\n    public withColumnsFilter(filterOnColumn: string[], filterColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY): this {\n        this._filterColumnMode = filterColumnMode;\n        this._filterColumns = filterOnColumn;\n        return this;\n    }\n\n    /**\n     * sets given type to column with given property and returns this table\n     * @param property column's property\n     * @param type custom type for column\n     * @param displayType custom column value display type\n     * @param args addition arguments for column\n     */\n    public withColumnPresetType(property: string, type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum, ...args: any[]): this {\n        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property).withTitle(property);\n        if (column) {\n            column.asType(type, displayType, ...args);\n        }\n        return this;\n    }\n\n    /**\n     * sets title to column with given property and returns this table\n     * @param property column's property\n     * @param title column's title\n     */\n    public withColumnTitle(property: string, title: string): this {\n        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property);\n        column.withTitle(title, true);\n        return this;\n    }\n\n    /**\n     * generates columns defined on table based on data fetched from api\n     * @param data data from api\n     */\n    public toTableDescriptorFromData(data: DataListResult): TableDescriptorInst<any> {\n        const tableDescriptor = this.toTableDescriptor();\n\n        if (data.data == null || data.data.length == 0) {\n            return tableDescriptor;\n        }\n\n        const objectModel = data.data[0];\n        const entries = flattenObjectKeys(objectModel)\n            .filter(([key]) => !this._excludedColumns.includes(key))\n            .filter(([, value]) => !Array.isArray(value)); //exclude arrays and sets\n\n        for (const [key, value] of entries) {\n            const metaColumn = this._columns.find(col => col.property === key);\n            let column: ColumnDescriptor<any, any>;\n            if (metaColumn) {\n                if (!metaColumn.visibility) {\n                    continue;\n                }\n                column = metaColumn.toColumnDescriptor();\n                tableDescriptor.withColumn(column);\n            } else {\n                column = tableDescriptor.addColumn(key).withTitle(key);\n                columnToDateNumberOrBoolean(column, value);\n            }\n\n            if (this.model.i18nBaseKey && !column.property.includes('rev')) {\n                column.withTitle([this.model.i18nBaseKey, 'properties', column.property].join('.').replace('state.', ''));\n            }\n\n            const elementOfSortColumns = this._sortColumns.includes(column.property);\n            if (\n                (this._sortColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfSortColumns) ||\n                (this._sortColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfSortColumns)\n            ) {\n                tableDescriptor.withSortUnsafe(column.property);\n            }\n\n            const elementOfFilterColumns = this._filterColumns.includes(column.property);\n            if (\n                this._filterColumns.length > 0 &&\n                ((this._filterColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfFilterColumns) ||\n                    (this._filterColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfFilterColumns))\n            ) {\n                tableDescriptor.addFilterFromColumnDescriptorUnsafe(column, false);\n            }\n        }\n\n        return tableDescriptor;\n    }\n\n    /**\n     * adds ColumnDynamicDescriptor to this table\n     * @param property column's property\n     */\n    public override addColumn(property: keyof any): ColumnDynamicDescriptor {\n        const column = new ColumnDynamicDescriptor(property as string);\n        this._columns.push(column);\n        return column;\n    }\n\n    public override removeColumn(property: keyof any): this {\n        const column = this.columns.find(col => col.property === property) ?? this.addColumn(property);\n        column.withVisibility(false);\n        return this;\n    }\n\n    /**\n     * creates deep copy of table dynamic descriptor\n     */\n    public override copy(): TableDynamicDescriptorInst {\n        const descriptor = new TableDynamicDescriptorInst(this.model.copy());\n        this.copyFieldsTo(descriptor);\n        descriptor._columns = this.columns.map(c => c.copy());\n        descriptor._excludedColumns = [...this._excludedColumns];\n        descriptor._filterColumns = [...this._filterColumns];\n        descriptor._sortColumns = [...this._sortColumns];\n        descriptor._filterColumnMode = this._filterColumnMode;\n        descriptor._sortColumnMode = this._sortColumnMode;\n        return descriptor;\n    }\n\n    public toTableDescriptor(): TableDescriptorInst<any> {\n        const descriptor = new TableDescriptorInst<any>(this.model);\n        this.copyFieldsTo(descriptor);\n        return descriptor;\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.descriptor.js","sourceRoot":"","sources":["../../../../../table/api/src/descriptors/table.descriptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {Type} from '@angular/core';\n\nimport {CommonsInternalError, DataListResult, EnumConstantType, ILookupDataProvider, ITableDescriptor, flattenObjectKeys} from '@mediusinc/mng-commons/core';\nimport {FilterDescriptor, FilterDisplayTypeEnum, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterTypeEnum} from '@mediusinc/mng-commons/filter';\nimport {EnumDescriptor, ModelDescriptor} from '@mediusinc/mng-commons/model';\n\nimport {columnToDateNumberOrBoolean} from '../helpers/class-attribute-converter';\nimport {ColumnDisplayTypeEnum, ColumnTypeEnum} from '../models/column.model';\nimport {IRowExpandableComponent} from '../models/row-expandable-component.model';\nimport {IColumnsManageInterface} from '../models/table-columns.model';\nimport {TableDynamicColumnsModeEnum, TablePaginationModeEnum, TableSizeEnum} from '../models/table.model';\nimport {ColumnDescriptor, ColumnDynamicDescriptor} from './column.descriptor';\nimport {SortDescriptor} from './sort.descriptor';\n\nexport class TableDescriptorInst<TableModel, Sorts = keyof TableModel, Filters = keyof TableModel>\n    implements ITableDescriptor<TableModel, Sorts, Filters>, IColumnsManageInterface<TableModel, Sorts, Filters>\n{\n    private readonly _model: ModelDescriptor<TableModel>;\n    protected readonly _autoGenerated;\n\n    private _identifier?: string;\n    private _trackProperty?: string;\n    private _paginationMode?: TablePaginationModeEnum;\n    private _rowsPerPageOptions?: number[];\n    private _defaultNumRows?: number;\n    protected _columns: Array<ColumnDescriptor<any, TableModel>> = [];\n    private _title?: string;\n    private _hideHeader = false;\n    private _loadingText?: string;\n    private _loadingIcon: string | null = 'pi pi-spinner';\n\n    // extra\n    private _hasHover = true;\n    private _hasGridlines = false;\n    private _hasResizableColumns = false;\n    private _columnResizeMode?: 'fit' | 'expand';\n\n    // special columns\n    private _selectionColumnFrozen?: boolean;\n    private _actionColumnFrozen?: boolean;\n\n    // styling\n    private _size: TableSizeEnum = TableSizeEnum.Large;\n    private _className = '';\n    private _headerClassName?: string;\n    private _rowClassName?: string;\n    private _rowClassNameMapFn?: (className?: string, item?: TableModel) => string;\n\n    // filters&sorts\n    private _filters: FilterDescriptor<any, TableModel>[] = [];\n    private _sorts: SortDescriptor<TableModel>[] = [];\n\n    // localization\n    private _isLocalized = false;\n    private _localizationLocaleProperty?: string;\n\n    // row expand\n    private _rowExpandable = false;\n    private _rowExpandableColSpan = 100;\n    private _rowExpandableProperty?: string;\n    private _rowExpandableComponentType?: Type<IRowExpandableComponent<TableModel>>;\n\n    // row reorder\n    private _rowReorderable = false;\n\n    public constructor(model: ModelDescriptor<TableModel>, autoGenerated = false) {\n        this._model = model;\n        this._trackProperty = this._model.idProperty;\n        this._autoGenerated = autoGenerated;\n    }\n\n    public get identifier() {\n        return this._identifier;\n    }\n\n    public get trackProperty() {\n        return this._trackProperty;\n    }\n\n    public get paginationMode() {\n        return this._paginationMode;\n    }\n\n    get rowsPerPageOptions() {\n        return this._rowsPerPageOptions;\n    }\n\n    get defaultNumRows() {\n        return this._defaultNumRows;\n    }\n\n    public get columns() {\n        return this._columns;\n    }\n\n    public get title() {\n        return this._title;\n    }\n\n    public get hideHeader() {\n        return this._hideHeader;\n    }\n\n    public get loadingText() {\n        return this._loadingText;\n    }\n\n    public get loadingIcon() {\n        return this._loadingIcon;\n    }\n\n    public get filters() {\n        return this._filters;\n    }\n\n    public get sorts() {\n        return this._sorts;\n    }\n\n    public get model() {\n        return this._model;\n    }\n\n    public get className() {\n        return this._className;\n    }\n\n    public get size() {\n        return this._size;\n    }\n\n    public get hasHover() {\n        return this._hasHover;\n    }\n\n    public get hasGridlines() {\n        return this._hasGridlines;\n    }\n\n    public get hasResizableColumns() {\n        return this._hasResizableColumns;\n    }\n\n    public get columnResizeMode() {\n        return this._columnResizeMode;\n    }\n\n    public get rowClassName() {\n        return this._rowClassName;\n    }\n\n    public get rowClassNameMapFn() {\n        return this._rowClassNameMapFn;\n    }\n\n    public get selectionColumnFrozen() {\n        return this._selectionColumnFrozen;\n    }\n\n    public get actionColumnFrozen() {\n        return this._actionColumnFrozen;\n    }\n\n    public get headerClassName() {\n        return this._headerClassName;\n    }\n\n    public get isLocalized() {\n        return this._isLocalized;\n    }\n\n    public get localizationLocaleProperty() {\n        return this._localizationLocaleProperty;\n    }\n\n    public get rowReorderable() {\n        return this._rowReorderable;\n    }\n\n    public get rowExpandable() {\n        return this._rowExpandable;\n    }\n\n    public get rowExpandableColSpan() {\n        return this._rowExpandableColSpan;\n    }\n\n    /**\n     * This table model property tells us if the specific row should be expandable or not based on row item value\n     */\n    public get rowExpandableProperty() {\n        return this._rowExpandableProperty;\n    }\n\n    /**\n     * This property is used to define the type of the custom component that will be used to render the expanded row.\n     */\n    public get rowExpandableComponentType() {\n        return this._rowExpandableComponentType;\n    }\n\n    /**\n     * Identifier 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.\n     * 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).\n     * @param identifier\n     */\n    public withIdentifier(identifier: string): this {\n        this._identifier = identifier;\n        return this;\n    }\n\n    /**\n     * Sets the track property (identifier of table row) for the table.\n     *\n     * @param {keyof TableModel} property - The property to track the row items by.\n     */\n    public withTrackProperty(property?: keyof TableModel): this {\n        return this.withTrackPropertyUnsafe(property as string);\n    }\n\n    /**\n     * Sets the track property (identifier of table row) for the table.\n     *\n     * This function is UNSAFE!\n     *\n     * @param {string} property - The property to set '_trackProperty' to.\n     */\n    public withTrackPropertyUnsafe(property?: string): this {\n        this._trackProperty = property;\n        return this;\n    }\n\n    /**\n     * Retrieves the column descriptor for the given property.\n     *\n     * @param {keyof TableModel} property - The property for column descriptor.\n     *\n     * @return The column descriptor.\n     */\n    public getColumn<Property extends keyof TableModel, ColumnModel = NonNullable<TableModel[Property]>, ColumnValue = TableModel[Property]>(\n        property: Property\n    ): ColumnDescriptor<ColumnModel, TableModel, ColumnValue> | null {\n        return this.getColumnUnsafe<ColumnModel, ColumnValue>(property as string);\n    }\n\n    /**\n     * Retrieves the column descriptor for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param {keyof TableModel} property - The property for column descriptor.\n     *\n     * @return The column descriptor.\n     */\n    public getColumnUnsafe<ColumnModel = any, ColumnValue = ColumnModel>(property: string): ColumnDescriptor<ColumnModel, TableModel, ColumnValue> | null {\n        return this._columns.find(col => col.property === property) ?? null;\n    }\n\n    /**\n     * Removes the column descriptor for the given property.\n     *\n     * @param {keyof TableModel} property - The property for column descriptor.\n     */\n    public removeColumn(property: keyof TableModel): void {\n        this.removeColumnUnsafe(property as string);\n    }\n\n    /**\n     * Removes the column descriptor for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param {keyof TableModel} property - The property for column descriptor.\n     */\n    public removeColumnUnsafe(property: string): void {\n        const columnIdx = this._columns.findIndex(c => c.property === property);\n        this._columns.splice(columnIdx, 1);\n    }\n\n    /**\n     * Adds column descriptor to table columns.\n     *\n     * @param {ColumnDescriptor<ColumnModel, TableModel, ColumnValue>} column - The property for column descriptor.\n     */\n    public withColumn<ColumnModel, ColumnValue = ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): this {\n        this._columns.push(column);\n        return this;\n    }\n\n    /**\n     * Adds a column to the table.\n     *\n     * @param {PropertyKey} property - The property key of the column in the table model.\n     *\n     * @returns The newly added column descriptor.\n     */\n    public addColumn<PropertyKey extends keyof TableModel>(property: PropertyKey) {\n        const column = new ColumnDescriptor<NonNullable<TableModel[PropertyKey]>, TableModel, TableModel[PropertyKey]>(property as string);\n        this._columns.push(column);\n        return column;\n    }\n\n    /**\n     * Adds a column with enum display to the table.\n     *\n     * @param {PropertyKey} property - The property key of the table model.\n     * @param {EnumDescriptor<Enum>} enumDesc - The enum descriptor for column display.\n     * @return {ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>} - The added column descriptor.\n     */\n    public addColumnEnum<PropertyKey extends keyof TableModel, Enum extends NonNullable<TableModel[PropertyKey]>>(property: PropertyKey, enumDesc: EnumDescriptor<Enum>) {\n        const column = new ColumnDescriptor<Enum, TableModel, TableModel[PropertyKey]>(property as string);\n        column.asEnumUnsafe(enumDesc);\n        this._columns.push(column);\n        return column;\n    }\n\n    /**\n     * Adds a column to the table.\n     *\n     * This function is UNSAFE!\n     *\n     * @param {string} property - The property key of the column in the table model.\n     *\n     * @returns The newly added column descriptor.\n     */\n    public addColumnUnsafe<ColumnModel = unknown>(property: string): ColumnDescriptor<ColumnModel, TableModel> {\n        const column = new ColumnDescriptor<ColumnModel, TableModel>(property);\n        this._columns.push(column);\n        return column;\n    }\n\n    /**\n     * Adds one or more columns to the table model.\n     *\n     * @param properties - An array of property names to add as columns.\n     */\n    public withColumns(...properties: (keyof TableModel)[]): this {\n        properties.forEach(p => this.addColumn(p));\n        return this;\n    }\n\n    /**\n     * Set the pagination mode for the table.\n     *\n     * @param {TablePaginationModeEnum} paginationMode - The pagination mode to set. Must be one of the values from the TablePaginationModeEnum.\n     */\n    public withPaginationMode(paginationMode: TablePaginationModeEnum): this {\n        this._paginationMode = paginationMode;\n        return this;\n    }\n\n    /**\n     * Sets the number of rows per page for a paginated display.\n     *\n     * @param {number} rows - The default number of rows to display per page.\n     * @param {Array<number>} [options] - Rows per page options to be available in table paginator.\n     */\n    public withRowsPerPage(rows: number, options?: Array<number>): this {\n        this._defaultNumRows = rows;\n        this._rowsPerPageOptions = options;\n        return this;\n    }\n\n    /**\n     * Sets the title for an instance of the class.\n     *\n     * @param {string} [title] - The title value to be set. It undefiend, no title will be displayed.\n     */\n    public withTitle(title?: string): this {\n        this._title = title;\n\n        return this;\n    }\n\n    /**\n     * Shows/hides the header row with column titles.\n     *\n     * @param {boolean} hideHeader - A boolean value indicating whether to hide the header.\n     */\n    public withHideHeader(hideHeader = true) {\n        this._hideHeader = hideHeader;\n        return this;\n    }\n\n    /**\n     * Adjusts loading display with custom text and/or icon.\n     *\n     * @param {string} [text] - Text to be displayed when loading indicator is shown.\n     * @param {string | null} [icon] - Icon to be used when loading indicator is shown.\n     */\n    public withLoading(text?: string, icon?: string | null): this {\n        this._loadingText = text;\n        this._loadingIcon = icon === undefined ? 'pi pi-spinner' : icon;\n        return this;\n    }\n\n    /**\n     * Retrieves the sort descriptor for a given property.\n     *\n     * @param {Sorts} property - The property to retrieve the sort for.\n     *\n     * @return {SortDescriptor<TableModel> | null} The sort descriptor or null.\n     */\n    public getSort(property: Sorts): SortDescriptor<TableModel> | null {\n        return this.getSortUnsafe(property as string);\n    }\n\n    /**\n     * Retrieves the sort descriptor for a given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param {Sorts} property - The property to retrieve the sort for.\n     *\n     * @return {SortDescriptor<TableModel> | null} The sort descriptor or null.\n     */\n    public getSortUnsafe(property: string): SortDescriptor<TableModel> | null {\n        return this._sorts.find(s => s.property === property) ?? null;\n    }\n\n    /**\n     * Removes the sort for a given property.\n     *\n     * @param {Sorts} property - The property to remove the sort for.\n     */\n    public removeSort(property: Sorts) {\n        return this.removeSortUnsafe(property as string);\n    }\n\n    /**\n     * Removes the sort for a given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param {Sorts} property - The property to remove the sort for.\n     */\n    public removeSortUnsafe(property: string) {\n        const sortIdx = this._sorts.findIndex(c => c.property === property);\n        this._sorts.splice(sortIdx, 1);\n    }\n\n    /**\n     * Adds sort for the given property.\n     *\n     * @param property Property to add the sort for.\n     * @param isDefault If default sorting is enabled.\n     * @param ascending If default sort should be ascending.\n     *\n     * @return Created sort descriptor.\n     */\n    public addSort(property: Sorts, isDefault = false, ascending?: boolean): SortDescriptor<TableModel> {\n        return this.addSortUnsafe(property as string, isDefault, ascending);\n    }\n\n    /**\n     * Adds sort for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Property to add the sort for.\n     * @param isDefault If default sorting is enabled.\n     * @param ascending If default sort should be ascending.\n\n     * @return Created sort descriptor.\n     */\n    public addSortUnsafe(property: string, isDefault = false, ascending?: boolean): SortDescriptor<TableModel> {\n        const sort = new SortDescriptor<TableModel>(property);\n        if (isDefault) {\n            const defaultOrderMax = this._sorts\n                .filter(s => s.defaultIsEnabled)\n                .reduce((acc, s) => (s.defaultOrder !== undefined && s.defaultOrder > acc ? s.defaultOrder : acc), -1);\n            sort.withDefaultSort(true, ascending, defaultOrderMax + 1);\n        }\n        this._sorts.push(sort);\n        return sort;\n    }\n\n    /**\n     * Adds sort for the given property.\n     *\n     * @param property Property to add the sort for.\n     * @param isDefault If default sorting is enabled.\n     * @param ascending If default sort should be ascending.\n     */\n    public withSort(property: Sorts, isDefault = false, ascending?: boolean): this {\n        return this.withSortUnsafe(property as string, isDefault, ascending);\n    }\n\n    /**\n     * Adds sort for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Property to add the sort for.\n     * @param isDefault If default sorting is enabled.\n     * @param ascending If default sort should be ascending.\n     */\n    public withSortUnsafe(property: string, isDefault = false, ascending?: boolean): this {\n        this.addSortUnsafe(property, isDefault, ascending);\n        return this;\n    }\n\n    /**\n     * Sets the default sorting for the property.\n     *\n     * @param property - The property to set default sort for.\n     * @param ascending - If the sorting should be ascending (default: true).\n     * @param order - The order for this default sort (default: 0).\n     * @param enabled - Enables/disabled the default sort.\n     */\n    public withDefaultSort(property: Sorts, ascending?: boolean, order?: number, enabled?: boolean): this {\n        return this.withDefaultSortUnsafe(property as string, ascending, order, enabled);\n    }\n\n    /**\n     * Sets the default sorting for the property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property - The property to set default sort for.\n     * @param ascending - If the sorting should be ascending (default: true).\n     * @param order - The order for this default sort (default: 0).\n     * @param enabled - Enables/disabled the default sort.\n     */\n    public withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: boolean): this {\n        let sort = this._sorts.find(s => s.property === property);\n        if (!sort) {\n            sort = new SortDescriptor(property);\n            this._sorts.push(sort);\n        }\n        sort.withDefaultSort(enabled ?? true, ascending, order);\n        return this;\n    }\n\n    /**\n     * Add sorts for more properties.\n     *\n     * @param properties Properties to add the sorts for.\n     */\n    public withSorts(...properties: Sorts[]): this {\n        return this.withSortsUnsafe(...(properties as string[]));\n    }\n\n    /**\n     * Add sorts for more properties.\n     *\n     * This function is UNSAFE!\n     *\n     * @param properties Properties to add the sorts for.\n     */\n    public withSortsUnsafe(...properties: string[]): this {\n        properties.forEach(p => {\n            this._sorts.push(new SortDescriptor(p));\n        });\n        return this;\n    }\n\n    /**\n     * Gets filter descriptor for given property.\n     *\n     * @param property Filter property\n     *\n     * @return Filter descriptor for property or null if not exists.\n     */\n    public getFilter<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : any>(property: Filters): FilterDescriptor<FilterModel, TableModel> | null {\n        return this.getFilterUnsafe<FilterModel>(property as string);\n    }\n\n    /**\n     * Gets filter descriptor for given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Filter property\n     *\n     * @return Filter descriptor for property or null if not exists.\n     */\n    public getFilterUnsafe<FilterModel = any>(property: string): FilterDescriptor<FilterModel, TableModel> | null {\n        return this._filters.find(s => s.property === property) ?? null;\n    }\n\n    /**\n     * Removes filter descriptor for given property.\n     *\n     * @param property Filter property\n     */\n    public removeFilter(property: Filters) {\n        return this.removeFilterUnsafe(property as string);\n    }\n\n    /**\n     * Removes filter descriptor for given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Filter property\n     */\n    public removeFilterUnsafe(property: string) {\n        const filterIdx = this._filters.findIndex(c => c.property === property);\n        this._filters.splice(filterIdx, 1);\n    }\n\n    /**\n     * Creates filter descriptor for the given property.\n     *\n     * @param property Filter property.\n     *\n     * @return Created filter descriptor.\n     */\n    public addFilter<FilterModel = Filters extends keyof TableModel ? TableModel[Filters] : never>(property: Filters): FilterDescriptor<FilterModel, TableModel> {\n        return this.addFilterUnsafe<FilterModel>(property as string);\n    }\n\n    /**\n     * Creates filter descriptor for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Filter property.\n     *\n     * @return Created filter descriptor.\n     */\n    public addFilterUnsafe<FilterModel>(property: string): FilterDescriptor<FilterModel, TableModel> {\n        const filter = new FilterDescriptor<FilterModel, TableModel>(property);\n        this._filters.push(filter);\n        return filter;\n    }\n\n    /**\n     * Creates filter lookup descriptor for the given property.\n     *\n     * @param property Filter property.\n     * @param provider Lookup provider.\n     * @param optionsValueProperty Property on lookup provider's item (FilterModel) that will be used as filter value.\n     *\n     * @return Created filter lookup descriptor.\n     */\n    public addFilterLookup<FilterModel = Filters extends keyof TableModel ? NonNullable<TableModel[Filters]> : never, Service = undefined>(\n        property: Filters,\n        provider?: ILookupDataProvider<FilterModel, Service>,\n        optionsValueProperty?: keyof FilterModel\n    ): FilterLookupDescriptor<FilterModel, TableModel, Service> {\n        return this.addFilterLookupUnsafe(property as string, provider, optionsValueProperty as string);\n    }\n\n    /**\n     * Creates filter lookup descriptor for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Filter property.\n     * @param provider Lookup provider.\n     * @param optionsValueProperty Property on lookup provider's item (FilterModel) that will be used as filter value.\n     *\n     * @return Created filter lookup descriptor.\n     */\n    public addFilterLookupUnsafe<FilterModel, Service = undefined>(\n        property: string,\n        provider?: ILookupDataProvider<FilterModel, Service>,\n        optionsValueProperty?: string\n    ): FilterLookupDescriptor<FilterModel, TableModel, Service> {\n        const filter = new FilterLookupDescriptor<FilterModel, TableModel, Service>(property, {\n            dataProvider: provider,\n            optionsValueProperty: optionsValueProperty\n        });\n        this._filters.push(filter);\n        return filter;\n    }\n\n    /**\n     * Creates filter lookup enum descriptor for the given property.\n     *\n     * @param property Filter property.\n     * @param enumDesc Descriptor for enum.\n     * @param options Optional options of enum values to be available to filter by.\n     *\n     * @return Created filter lookup enum descriptor.\n     */\n    public addFilterLookupEnum<Enum>(property: Filters, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>) {\n        return this.addFilterLookupEnumUnsafe<Enum>(property as string, enumDesc, options);\n    }\n\n    /**\n     * Creates filter lookup enum descriptor for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Filter property.\n     * @param enumDesc Descriptor for enum.\n     * @param options Optional options of enum values to be available to filter by.\n     *\n     * @return Created filter lookup enum descriptor.\n     */\n    public addFilterLookupEnumUnsafe<Enum = EnumConstantType>(property: string, enumDesc: EnumDescriptor<Enum>, options?: Array<Enum>) {\n        const filter = new FilterLookupEnumDescriptor(property, enumDesc, options);\n        this._filters.push(filter);\n        return filter;\n    }\n\n    /**\n     * Creates filter descriptor from column. The column must exist on table descriptor.\n     *\n     * @param property Column property to add filter for.\n     * @param displayType Optional display type setting.\n     * @param forceSimple Forces simple creation of filter (no lookup or lookup enum filters).\n     *\n     * @throws {CommonsInternalError} If column for property doesn't exist.\n     *\n     * @return Created filter descriptor\n     */\n    public addFilterFromColumn<Property extends keyof TableModel, FilterModel = NonNullable<TableModel[Property]>>(\n        property: Extract<Filters, Property>,\n        displayType?: FilterDisplayTypeEnum,\n        forceSimple = false\n    ): FilterDescriptor<FilterModel, TableModel> {\n        return this.addFilterFromColumnUnsafe(property as string, displayType, forceSimple);\n    }\n\n    /**\n     * Creates filter descriptors from columns. The columns must exist on table descriptor.\n     *\n     * @param properties Column properties to add filters for.\n     *\n     * @throws {CommonsInternalError} If column for property doesn't exist.\n     */\n    public withFiltersFromColumns(...properties: Extract<Filters, keyof TableModel>[]): this {\n        return this.withFiltersFromColumnsUnsafe(...(properties as string[]));\n    }\n\n    /**\n     * Creates filter descriptors from columns. The columns must exist on table descriptor.\n     *\n     * This function is UNSAFE!\n     *\n     * @param properties Column properties to add filters for.\n     *\n     * @throws {CommonsInternalError} If column for property doesn't exist.\n     */\n    public withFiltersFromColumnsUnsafe(...properties: string[]): this {\n        properties.forEach(p => {\n            this.addFilterFromColumnUnsafe(p);\n        });\n        return this;\n    }\n\n    /**\n     * Creates filter descriptor from column. The column must exist on table descriptor.\n     *\n     * This function is UNSAFE!\n     *\n     * @param property Column property to add filter for.\n     * @param displayType Optional display type setting.\n     * @param forceSimple Forces simple creation of filter (no lookup or lookup enum filters).\n     *\n     * @throws {CommonsInternalError} If column for property doesn't exist.\n     *\n     * @return Created filter descriptor\n     */\n    public addFilterFromColumnUnsafe<FilterModel = any>(property: string, displayType?: FilterDisplayTypeEnum, forceSimple = false): FilterDescriptor<FilterModel, TableModel> {\n        const column = this.getColumnUnsafe<FilterModel, any>(property);\n        if (!column) {\n            throw new CommonsInternalError(`No column found for filter property \"${property}\"`);\n        }\n        const filter = this.addFilterFromColumnDescriptorUnsafe<FilterModel>(column, forceSimple);\n        if (displayType != null) filter.withDisplayType(displayType);\n        return filter;\n    }\n\n    /**\n     * Creates filter descriptor from provided column descriptor.\n     *\n     * This function is UNSAFE!\n     *\n     * @param column Column descriptor.\n     * @param forceSimple Forces simple creation of filter (no lookup or lookup enum filters).\n     *\n     * @throws {CommonsInternalError} If column for property doesn't exist.\n     *\n     * @return Created filter descriptor\n     */\n    public addFilterFromColumnDescriptorUnsafe<FilterModel>(\n        column: ColumnDescriptor<FilterModel, TableModel, any>,\n        forceSimple = false\n    ): FilterDescriptor<FilterModel, TableModel> {\n        let filterDescriptor = new FilterDescriptor<FilterModel, TableModel>(column.property);\n        let filterType: FilterTypeEnum;\n\n        switch (column.columnType) {\n            case ColumnTypeEnum.Number:\n                filterType = FilterTypeEnum.Number;\n                break;\n            case ColumnTypeEnum.Boolean:\n                filterType = FilterTypeEnum.Boolean;\n                break;\n            case ColumnTypeEnum.Date:\n                filterType = FilterTypeEnum.Date;\n                break;\n            case ColumnTypeEnum.Enum:\n                if (!forceSimple && column.enum) {\n                    filterDescriptor = new FilterLookupEnumDescriptor(column.property, column.enum) as FilterDescriptor<FilterModel, TableModel>;\n                    filterType = FilterTypeEnum.LookupEnum;\n                } else {\n                    filterType = FilterTypeEnum.String;\n                }\n                break;\n            case ColumnTypeEnum.String:\n            case ColumnTypeEnum.Custom:\n            default:\n                filterType = FilterTypeEnum.String;\n                break;\n        }\n\n        filterDescriptor.asFilterType(filterType);\n        if ((filterType === FilterTypeEnum.Number || filterType === FilterTypeEnum.Date) && column.displayFormat) {\n            filterDescriptor.withDisplayFormat(column.displayFormat, true);\n        }\n\n        this._filters.push(filterDescriptor);\n\n        return filterDescriptor;\n    }\n\n    /**\n     * Adds filter descriptor for the given property.\n     *\n     * @param property Filter property.\n     * @param filter Descriptor for property.\n     */\n    public withFilter<FilterModel>(property: Filters, filter: FilterDescriptor<FilterModel, TableModel>): this {\n        if (filter.property !== property) {\n            throw new CommonsInternalError(`Filter property \"${property}\" and Filter descriptor property \"${filter.property}\" do not match.`);\n        }\n        return this.withFilterUnsafe<FilterModel>(filter);\n    }\n\n    /**\n     * Adds filter descriptor for the given property.\n     *\n     * This function is UNSAFE!\n     *\n     * @param filter Descriptor for property.\n     */\n    public withFilterUnsafe<FilterModel>(filter: FilterDescriptor<FilterModel, TableModel>): this {\n        this._filters.push(filter);\n        return this;\n    }\n\n    /**\n     * Sets classes for table component.\n     *\n     * @param className Class names.\n     */\n    public withClassName(className: string): this {\n        this._className = className;\n        return this;\n    }\n\n    /**\n     * Sets table sizing.\n     *\n     * @param size Table size.\n     */\n    public withSize(size: TableSizeEnum = TableSizeEnum.Normal): this {\n        this._size = size;\n        return this;\n    }\n\n    /**\n     * Enables hover effect on table rows.\n     *\n     * @param hover Enables/disables the hover.\n     */\n    public withHover(hover = true): this {\n        this._hasHover = hover;\n        return this;\n    }\n\n    /**\n     * Enables gridlines on table.\n     *\n     * @param gridlines Enables/disables the gridlines.\n     */\n    public withGridlines(gridlines = true): this {\n        this._hasGridlines = gridlines;\n        return this;\n    }\n\n    /**\n     * Enables/disables reorderable property on all columns currently in the descriptor.\n     *\n     * @param {boolean} [columnsReorderable] - Boolean flag to set reordering on columns to.\n     */\n    public withCurrentColumnsReorderable(columnsReorderable = true): this {\n        for (const col of this.columns) {\n            col.withReorderable(columnsReorderable);\n        }\n        return this;\n    }\n\n    /**\n     * Enables/disables toggleable property on all columns currently in the descriptor.\n     *\n     * @param {boolean} [columnsToggleable] - Boolean flag to set toggleable on columns to.\n     */\n    public withCurrentColumnsToggleable(columnsToggleable = true): this {\n        for (const col of this.columns) {\n            col.withToggleable(columnsToggleable);\n        }\n        return this;\n    }\n\n    /**\n     * Enables/disabled column resize feature with columnResizeMode on all columns.\n     *\n     * @param resizableColumns True if enabled\n     * @param columnResizeMode 'fit' or 'expand' mode\n     */\n    public withColumnsResizable(resizableColumns = true, columnResizeMode: 'fit' | 'expand' = 'fit'): this {\n        this._hasResizableColumns = resizableColumns;\n        this._columnResizeMode = columnResizeMode;\n        return this;\n    }\n\n    /**\n     * Sets column to (un)frozen.\n     *\n     * @param selectionColumnFrozen True to freeze selection column, false to unfreeze it.\n     * @param actionColumnFrozen True to freeze action column, false to unfreeze it.\n     */\n    public withColumnFrozen(selectionColumnFrozen?: boolean, actionColumnFrozen?: boolean): this {\n        this._selectionColumnFrozen = selectionColumnFrozen;\n        this._actionColumnFrozen = actionColumnFrozen;\n        return this;\n    }\n\n    /**\n     * Sets the class name for rows in the table.\n     *\n     * @param {string} rowClassName - The CSS class name to be applied to each row.\n     * @param {function} [classNameMapFn] - Optional function to map the class name dynamically based on row's item and current class name.\n     */\n    public withRowClassName(rowClassName?: string, classNameMapFn?: (className?: string, item?: TableModel) => string): this {\n        this._rowClassName = rowClassName;\n        this._rowClassNameMapFn = classNameMapFn;\n        return this;\n    }\n\n    /**\n     * Sets header row class name.\n     *\n     * @param headerClassName Class name.\n     */\n    public withHeaderClassName(headerClassName: string): this {\n        this._headerClassName = headerClassName;\n        return this;\n    }\n\n    /**\n     * Enables localization of the table.\n     */\n    public withLocalized(): this {\n        this._isLocalized = true;\n        return this;\n    }\n\n    /**\n     * Sets locale property for localization.\n     *\n     * @param property Locale property\n     */\n    public withLocalizationLocaleProperty(property: string): this {\n        this._isLocalized = true;\n        this._localizationLocaleProperty = property;\n        return this;\n    }\n\n    /**\n     * Enables row expanding.\n     *\n     * @param property Property to check if row can be expanded.\n     * @param colSpan set custom row span for expanded row.\n     * @param componentType Component to be displayed on row expand.\n     */\n    public withRowExpandable(property?: keyof TableModel, colSpan?: number, componentType?: Type<IRowExpandableComponent<TableModel>>): this {\n        this._rowExpandable = true;\n        if (property) {\n            this._rowExpandableProperty = property as string;\n        }\n        if (colSpan) {\n            this._rowExpandableColSpan = colSpan;\n        }\n        if (componentType) {\n            this._rowExpandableComponentType = componentType;\n        }\n        return this;\n    }\n\n    /**\n     * Enables row reordering.\n     *\n     * @param reordable Enables/disables feature.\n     */\n    withRowReorderable(reordable = true) {\n        this._rowReorderable = reordable;\n        return this;\n    }\n\n    protected copyFieldsTo(obj: TableDescriptorInst<any, any, any>) {\n        obj._title = this._title;\n        obj._hideHeader = this._hideHeader;\n        obj._trackProperty = this._trackProperty;\n        obj._filters = this._filters.map(f => f.copy());\n        obj._sorts = this._sorts.map(s => s.copy());\n        obj._className = this._className;\n        obj._size = this._size;\n        obj._hasHover = this._hasHover;\n        obj._hasGridlines = this._hasGridlines;\n        obj._hasResizableColumns = this._hasResizableColumns;\n        obj._columnResizeMode = this._columnResizeMode;\n        obj._actionColumnFrozen = this._actionColumnFrozen;\n        obj._selectionColumnFrozen = this._selectionColumnFrozen;\n        obj._isLocalized = this._isLocalized;\n        obj._localizationLocaleProperty = this._localizationLocaleProperty;\n        obj._paginationMode = this._paginationMode;\n        obj._rowsPerPageOptions = this._rowsPerPageOptions;\n        obj._rowExpandable = this._rowExpandable;\n        obj._rowExpandableColSpan = this._rowExpandableColSpan;\n        obj._rowExpandableProperty = this._rowExpandableProperty;\n        obj._rowExpandableComponentType = this._rowExpandableComponentType;\n        obj._rowReorderable = this._rowReorderable;\n    }\n\n    /**\n     * Copies current descriptor to a new instance.\n     */\n    public copy(): TableDescriptorInst<TableModel, Sorts, Filters> {\n        const descriptor = new TableDescriptorInst<TableModel, Sorts, Filters>(this.model.copy());\n        this.copyFieldsTo(descriptor);\n        descriptor._columns = this.columns.map(c => c.copy());\n        return descriptor;\n    }\n}\n\nexport class TableDynamicDescriptorInst extends TableDescriptorInst<any> {\n    private _excludedColumns: Array<string> = [];\n    private _filterColumns: Array<string> = [];\n    private _sortColumns: Array<string> = [];\n    private _sortColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;\n    private _filterColumnMode = TableDynamicColumnsModeEnum.EXCLUDE;\n\n    protected override _columns: ColumnDynamicDescriptor[] = [];\n\n    public constructor(model: ModelDescriptor<any>) {\n        super(model);\n\n        if (typeof model.titleProperty === 'string') {\n            this.withTitle(model.titleProperty);\n        }\n    }\n\n    public override get columns() {\n        return this._columns;\n    }\n\n    /**\n     * defines excluded columns when generating descriptor\n     * @param excludedColumn names of excluded columns\n     */\n    public withColumnsExcluded(excludedColumn: string[]): this {\n        this._excludedColumns = excludedColumn;\n        return this;\n    }\n\n    /**\n     * defines column properties on which sort is defined or not depending on sortColumnMode\n     * @param sortOnColumns column names\n     * @param sortColumnMode INCLUDE_ONLY (default) only given columns will have sort, EXCLUDE given columns will NOT have sort\n     */\n    public withColumnsSort(sortOnColumns: string[], sortColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY): this {\n        this._sortColumnMode = sortColumnMode;\n        this._sortColumns = sortOnColumns;\n        return this;\n    }\n\n    /**\n     * defines column properties on which filter is defined or not depending on filterColumnMode\n     * @param filterOnColumn column names\n     * @param filterColumnMode INCLUDE_ONLY (default) only given columns will have filter, EXCLUDE given columns will NOT have filter\n     */\n    public withColumnsFilter(filterOnColumn: string[], filterColumnMode = TableDynamicColumnsModeEnum.INCLUDE_ONLY): this {\n        this._filterColumnMode = filterColumnMode;\n        this._filterColumns = filterOnColumn;\n        return this;\n    }\n\n    /**\n     * sets given type to column with given property and returns this table\n     * @param property column's property\n     * @param type custom type for column\n     * @param displayType custom column value display type\n     * @param args addition arguments for column\n     */\n    public withColumnPresetType(property: string, type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum, ...args: any[]): this {\n        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property).withTitle(property);\n        if (column) {\n            column.asType(type, displayType, ...args);\n        }\n        return this;\n    }\n\n    /**\n     * sets title to column with given property and returns this table\n     * @param property column's property\n     * @param title column's title\n     */\n    public withColumnTitle(property: string, title: string): this {\n        const column = this._columns.find(col => property === col.property) ?? this.addColumn(property);\n        column.withTitle(title, true);\n        return this;\n    }\n\n    /**\n     * generates columns defined on table based on data fetched from api\n     * @param data data from api\n     */\n    public toTableDescriptorFromData(data: DataListResult): TableDescriptorInst<any> {\n        const tableDescriptor = this.toTableDescriptor();\n\n        if (data.data == null || data.data.length == 0) {\n            return tableDescriptor;\n        }\n\n        const objectModel = data.data[0];\n        const entries = flattenObjectKeys(objectModel)\n            .filter(([key]) => !this._excludedColumns.includes(key))\n            .filter(([, value]) => !Array.isArray(value)); //exclude arrays and sets\n\n        for (const [key, value] of entries) {\n            const metaColumn = this._columns.find(col => col.property === key);\n            let column: ColumnDescriptor<any, any>;\n            if (metaColumn) {\n                if (!metaColumn.visibility) {\n                    continue;\n                }\n                column = metaColumn.toColumnDescriptor();\n                tableDescriptor.withColumn(column);\n            } else {\n                column = tableDescriptor.addColumn(key).withTitle(key);\n                columnToDateNumberOrBoolean(column, value);\n            }\n\n            if (this.model.i18nBaseKey && !column.property.includes('rev')) {\n                column.withTitle([this.model.i18nBaseKey, 'properties', column.property].join('.').replace('state.', ''));\n            }\n\n            const elementOfSortColumns = this._sortColumns.includes(column.property);\n            if (\n                (this._sortColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfSortColumns) ||\n                (this._sortColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfSortColumns)\n            ) {\n                tableDescriptor.withSortUnsafe(column.property);\n            }\n\n            const elementOfFilterColumns = this._filterColumns.includes(column.property);\n            if (\n                this._filterColumns.length > 0 &&\n                ((this._filterColumnMode === TableDynamicColumnsModeEnum.EXCLUDE && !elementOfFilterColumns) ||\n                    (this._filterColumnMode === TableDynamicColumnsModeEnum.INCLUDE_ONLY && elementOfFilterColumns))\n            ) {\n                tableDescriptor.addFilterFromColumnDescriptorUnsafe(column, false);\n            }\n        }\n\n        return tableDescriptor;\n    }\n\n    /**\n     * adds ColumnDynamicDescriptor to this table\n     * @param property column's property\n     */\n    public override addColumn(property: keyof any): ColumnDynamicDescriptor {\n        const column = new ColumnDynamicDescriptor(property as string);\n        this._columns.push(column);\n        return column;\n    }\n\n    public override removeColumn(property: keyof any): this {\n        const column = this.columns.find(col => col.property === property) ?? this.addColumn(property);\n        column.withVisibility(false);\n        return this;\n    }\n\n    /**\n     * creates deep copy of table dynamic descriptor\n     */\n    public override copy(): TableDynamicDescriptorInst {\n        const descriptor = new TableDynamicDescriptorInst(this.model.copy());\n        this.copyFieldsTo(descriptor);\n        descriptor._columns = this.columns.map(c => c.copy());\n        descriptor._excludedColumns = [...this._excludedColumns];\n        descriptor._filterColumns = [...this._filterColumns];\n        descriptor._sortColumns = [...this._sortColumns];\n        descriptor._filterColumnMode = this._filterColumnMode;\n        descriptor._sortColumnMode = this._sortColumnMode;\n        return descriptor;\n    }\n\n    public toTableDescriptor(): TableDescriptorInst<any> {\n        const descriptor = new TableDescriptorInst<any>(this.model);\n        this.copyFieldsTo(descriptor);\n        return descriptor;\n    }\n}\n"]}