@ardium-ui/ui 1.0.0

package/esm2022/lib/table/table-item-storage.mjs

@@ -0,0 +1,560 @@
+import resolvePath from 'resolve-object-path';
+import { evaluate, isDefined, isNull } from 'simple-bool';
+import { SortType, TablePaginationStrategy } from './table.types';
+import { areAllDataColumns, isTableSubheader, merge2dArrays } from './utils';
+export class HeaderCell {
+    get width() {
+        if (isTableSubheader(this.cell))
+            return null;
+        return this._getWidth(this.cell.width);
+    }
+    get minWidth() {
+        if (isTableSubheader(this.cell))
+            return null;
+        return this._getWidth(this.cell.minWidth);
+    }
+    _getWidth(width) {
+        if (!width)
+            return null;
+        if (typeof width == 'number')
+            return `${width}px`;
+        return width;
+    }
+    constructor(cell, colspan = 1, rowspan = 1) {
+        this.cell = cell;
+        this.colspan = colspan;
+        this.rowspan = rowspan;
+    }
+}
+export class TableItemStorage {
+    constructor(_ardParentComp) {
+        this._ardParentComp = _ardParentComp;
+        this._items = [];
+        this._sortedItems = [];
+        this._highlightedItems = [];
+        this._selectedItems = [];
+        this._dataColumns = [];
+        this._headerCells = [];
+        //! sorting
+        this._currentSortColumn = null;
+        this._currentSortType = null;
+    }
+    /**
+     * Gets all items.
+     */
+    get items() {
+        return this._items;
+    }
+    get sortedItems() {
+        return this._sortedItems;
+    }
+    /**
+     * Gets items based on the current pagination state.
+     */
+    get paginatedItems() {
+        //prettier-ignore
+        if (!this._ardParentComp.paginated
+            || this._ardParentComp.paginationStrategy == TablePaginationStrategy.Noop) {
+            return this.sortedItems;
+        }
+        const page = this._ardParentComp.page;
+        const IPP = this._ardParentComp.itemsPerPage;
+        const itemsStart = (page - 1) * IPP;
+        const itemsEnd = page * IPP;
+        return this.sortedItems.slice(itemsStart, itemsEnd);
+    }
+    /**
+     * Gets all currently selected items.
+     */
+    get selectedItems() {
+        return this._selectedItems;
+    }
+    /**
+     * Gets all currently highlighted items.
+     */
+    get highlightedItems() {
+        return this._highlightedItems;
+    }
+    /**
+     * Gets the values of the currently selected items.
+     */
+    get value() {
+        return this._itemsToValue(this.selectedItems);
+    }
+    /**
+     * Maps an array of items into their values.
+     * @param items The items to convert to value.
+     * @returns An array of item values.
+     */
+    _itemsToValue(items) {
+        return items.map(item => item.itemData);
+    }
+    /**
+     * Returns true if at least one item is highlighted, otherwise false.
+     */
+    get isAnyItemHighlighted() {
+        return this._highlightedItems.length > 0;
+    }
+    /**
+     * Checks if any item in the table is selected.
+     * @returns A boolean value indicating if any item is selected.
+     */
+    get isAnyItemSelected() {
+        return this._selectedItems.length > 0;
+    }
+    /**
+     * Checks if all items in the table are selected.
+     * @returns A boolean value indicating if all items are selected.
+     */
+    get areAllSelected() {
+        return this._selectedItems.length == this._items.filter(item => !item.disabled).length;
+    }
+    /**
+     * Returns true if the parent component defines the limit of concurrently selectable items and the amount of currently selected items matches that limit. Otherwise returns false.
+     *
+     * **TLDR**: true if `maxSelectedItems` is defined and the number of selected items matches that value.
+     */
+    get isItemLimitReached() {
+        if (!isDefined(this._ardParentComp.maxSelectedItems)) {
+            return false;
+        }
+        return this._ardParentComp.maxSelectedItems <= this.selectedItems.length;
+    }
+    /**
+     * Gets the header cells of the table.
+     * @returns a 2D array of header cells.
+     */
+    get headerCells() {
+        return this._headerCells;
+    }
+    /**
+     * Checks if the table has defined columns.
+     * @returns a boolean value indicating if the table has defined columns.
+     */
+    get hasDefinedColumns() {
+        return this._dataColumns.length > 0;
+    }
+    //! setting columns
+    /**
+     * Sets the columns of the table.
+     * @param cols an array of table data columns or table subheaders.
+     */
+    setColumns(cols) {
+        const maxNestingLevel = this._getHeaderMaxNesting(cols);
+        const headerCells = this._mapColumnsToArray(cols, maxNestingLevel, 0);
+        this._headerCells = this._filterHeaderCells(headerCells);
+        this._dataColumns = this._extractDataSources(cols);
+    }
+    /**
+     * Filters out null values from the header cells array.
+     * @param cells a 2D array of header cells or null values.
+     * @returns a 2D array of header cells without null values and empty arrays.
+     */
+    _filterHeaderCells(cells) {
+        for (let i = 0; i < cells.length; i++) {
+            cells[i] = cells[i].filter(v => v != null);
+        }
+        return cells.filter(row => row.length);
+    }
+    /**
+     * Extracts the data sources from the columns array.
+     * @param cols an array of table data columns or table subheaders.
+     * @returns an array of table data columns.
+     */
+    _extractDataSources(cols) {
+        let dataColumns = [];
+        for (const col of cols) {
+            if (!isTableSubheader(col)) {
+                dataColumns.push(col);
+                continue;
+            }
+            dataColumns.push(...this._extractDataSources(col.children));
+        }
+        return dataColumns;
+    }
+    /**
+     * Gets the maximum nesting level of the columns array.
+     * @param cols an array of table data columns or table subheaders.
+     * @returns the maximum nesting level as a number.
+     */
+    _getHeaderMaxNesting(cols) {
+        if (areAllDataColumns(cols))
+            return 1;
+        let max = 1;
+        for (const col of cols.filter(v => isTableSubheader(v))) {
+            const height = 1 + this._getHeaderMaxNesting(col.children);
+            if (height > max)
+                max = height;
+        }
+        return max;
+    }
+    /**
+     * Maps the columns tree to a 2D array of header cells or null values.
+     * @param cols an array of table data columns or table subheaders.
+     * @param maxNesting the maximum nesting level of the columns array.
+     * @param currentNesting the current nesting level of the columns array.
+     * @returns a 2D array of header cells or null values.
+     */
+    _mapColumnsToArray(cols, maxNesting, currentNesting) {
+        if (areAllDataColumns(cols)) {
+            return [cols.map(col => new HeaderCell(col, 1, maxNesting - currentNesting))];
+        }
+        const headerCells = [[]];
+        for (const col of cols) {
+            if (!isTableSubheader(col)) {
+                headerCells[0].push(new HeaderCell(col, 1, maxNesting - currentNesting));
+                continue;
+            }
+            const childCells = [[], ...this._mapColumnsToArray(col.children, maxNesting, currentNesting + 1)];
+            const height = childCells.length - 1;
+            const width = childCells[1].length;
+            for (let i = 0; i < height; i++) {
+                headerCells.push([null]);
+            }
+            headerCells[0].push(new HeaderCell(col, width, 1));
+            for (let i = 0; i < width - 1; i++) {
+                headerCells[0].push(null);
+            }
+            merge2dArrays(headerCells, childCells);
+        }
+        return headerCells;
+    }
+    //! setting items
+    /**
+     * Sets the component's items. Takes into account the values defined by the parent component for `rowDisabledFrom`, `rowBoldFrom`, and `rowHighlightedFrom`.
+     * @param items An array of items to be set as the component's items.
+     */
+    setItems(items) {
+        if (!this.hasDefinedColumns)
+            return;
+        this._items = items.map((item, index) => {
+            return this._setItemsMapFn(item, index);
+        });
+        this._sortedItems = this._items;
+    }
+    /**
+     * Maps raw item data to an {@link ArdTableRow} object.
+     *
+     * @param {any} rawItemData - The raw data of the item.
+     * @param {number} index - The index of the item.
+     * @returns {ArdTableRow} Returns an ArdTableRow object with mapped properties.
+     * @private
+     */
+    _setItemsMapFn(rawItemData, index) {
+        //get data
+        const [data, dataColumns] = this._getRowData(rawItemData, index);
+        //get bold
+        const rowBoldFromPath = this._ardParentComp.rowBoldFrom ?? this._ardParentComp.DEFAULTS.rowBoldFrom;
+        let bold = resolvePath(rawItemData, rowBoldFromPath);
+        if (this._ardParentComp.invertRowBold) {
+            bold = !bold;
+        }
+        //get disabled
+        const disabledPath = this._ardParentComp.rowDisabledFrom ?? this._ardParentComp.DEFAULTS.rowDisabledFrom;
+        let disabled = evaluate(resolvePath(rawItemData, disabledPath));
+        if (this._ardParentComp.invertRowDisabled) {
+            disabled = !disabled;
+        }
+        //return
+        return {
+            itemData: rawItemData,
+            index,
+            data,
+            dataColumns,
+            disabled,
+            bold,
+        };
+    }
+    /**
+     * Retrieves data for a row based on data columns configuration.
+     *
+     * @param {any} rawItemData - The raw data of the item.
+     * @param {number} index - The index of the item.
+     * @returns {any[]} Returns an array containing the row data.
+     * @private
+     */
+    _getRowData(rawItemData, index) {
+        let data = [];
+        for (const dataColumn of this._dataColumns) {
+            const sourcePath = dataColumn.dataSource;
+            if (typeof sourcePath == 'string') {
+                if (this._ardParentComp.treatDataSourceAsString) {
+                    data.push(rawItemData[sourcePath]);
+                    continue;
+                }
+                data.push(resolvePath(rawItemData, sourcePath));
+                continue;
+            }
+            if (sourcePath.type == 'autocount') {
+                data.push(index + 1);
+                continue;
+            }
+            if (sourcePath.type == 'checkbox') {
+                data.push({ _ardCheckbox: true, index });
+                continue;
+            }
+            const sourceString = typeof sourcePath == 'object' ? JSON.stringify(sourcePath) : sourcePath;
+            console.error(new Error(`Unexpected data source "${sourceString}".`));
+        }
+        return [data, this._dataColumns];
+    }
+    /**
+     * Writes a new value to the item storage. Selects the correct items based on the provided values, warning the user if the value is not found.
+     * @param indexes The value of the ngModel to set.
+     */
+    writeValue(indexes) {
+        this._forceUnselectAll();
+        this.selectItem(...indexes);
+    }
+    //! selecting items
+    /**
+     * Checks if an item with the given index is selected.
+     *
+     * @param {number} index The index of the item to check.
+     * @returns {boolean} _true_ if the item is selected, otherwise _false_.
+     */
+    isItemSelected(index) {
+        return this._selectedItems.some(item => item.index == index);
+    }
+    /**
+     * Selects all items.
+     *
+     * Accounts for the limit of concurrently selected items defined by the parent component.
+     * @returns a tuple containing two arrays:
+     * * An array of items selected.
+     * * An array of items failed to select.
+     */
+    selectAll() {
+        return this.selectItem(...this._items.map(v => v.index));
+    }
+    /**
+     * Unselects all selected items.
+     *
+     * If the parent component requires at least one value to be selected at all times, the first selected items is left selected.
+     * @returns An array of items cleared, mapped to only their values.
+     */
+    unselectAll() {
+        for (const item of this._selectedItems) {
+            item.selected = false;
+        }
+        const ret = this._itemsToValue(this._selectedItems);
+        this._selectedItems = [];
+        return ret;
+    }
+    /**
+     * Unselects all selected items, no matter what the component settings are.
+     * @returns An array of items cleared, mapped to only their values.
+     */
+    _forceUnselectAll() {
+        for (const item of this._selectedItems) {
+            item.selected = false;
+        }
+        const ret = this._itemsToValue(this._selectedItems);
+        this._selectedItems = [];
+        return ret;
+    }
+    /**
+     * Selects one or multiple items.
+     *
+     * Accounts for the limit of concurrently selected items defined by the parent component.
+     *
+     * @param indexes A rest operator array of item indexes to be selected.
+     * @returns a tuple containing two arrays:
+     * * An array of items selected.
+     * * An array of items failed to select.
+     */
+    selectItem(...indexes) {
+        const itemsToBeSelected = this._items.filter(item => !item.disabled && indexes.includes(item.index));
+        if (this.isItemLimitReached) {
+            return [[], this._itemsToValue(itemsToBeSelected)];
+        }
+        let itemsSelectedCount = 0;
+        const itemsSelected = [];
+        for (const item of itemsToBeSelected) {
+            itemsSelectedCount++;
+            if (item.selected)
+                continue;
+            if (this.isItemLimitReached) {
+                break;
+            }
+            item.selected = true;
+            this._selectedItems.push(item);
+            itemsSelected.push(item);
+        }
+        const itemsFailedToSelect = itemsToBeSelected.slice(itemsSelectedCount - 1);
+        return [this._itemsToValue(itemsSelected), this._itemsToValue(itemsFailedToSelect)];
+    }
+    /**
+     * Unselects one or multiple items.
+     * @param items A rest operator array of item indexes to be unselected.
+     * @returns An array of items unselected, mapped to only their values.
+     */
+    unselectItem(...indexes) {
+        const itemsToBeSelected = this._items.filter(item => indexes.includes(item.index));
+        for (const item of itemsToBeSelected) {
+            item.selected = false;
+        }
+        this._selectedItems = this._selectedItems.filter(v => v.selected);
+        return this._itemsToValue(itemsToBeSelected);
+    }
+    //! highlighting items
+    /**
+     * Unhighlights all currently highlighted items.
+     */
+    unhighlightAll() {
+        for (const item of this._highlightedItems) {
+            item.highlighted = false;
+        }
+        this._highlightedItems = [];
+    }
+    /**
+     * Highlights the given item, while unhighlighting all other items. Does nothing when the item is disabled.
+     * @param item The index of the item to be highlighted.
+     * @returns The highlighted item.
+     */
+    highlightSingleItem(index) {
+        this.unhighlightAll();
+        return this.highlightItem(index);
+    }
+    /**
+     * Highlights all given items.
+     * @param items A rest operator array of item indexes to be highlighted.
+     * @returns The last highlighted item.
+     */
+    highlightItem(...indexes) {
+        const items = this._items.filter(item => indexes.includes(item.index));
+        for (const item of items) {
+            item.highlighted = true;
+        }
+        this._highlightedItems.push(...items);
+        return items.last();
+    }
+    /**
+     * Unhighlights all given items.
+     * @param items A rest operator array of item indexes to be unhighlighted.
+     */
+    unhighlightItem(...indexes) {
+        const items = this._items.filter(item => indexes.includes(item.index));
+        for (const item of items) {
+            if (!item || !item.highlighted)
+                return;
+            item.highlighted = false;
+        }
+        this._highlightedItems = this._highlightedItems.filter(v => v.highlighted);
+    }
+    /**
+     * Highlights the first item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightFirstItem() {
+        this.unhighlightAll();
+        let itemToHighlight = this._getHiglightableItems().first().index;
+        return this.highlightItem(itemToHighlight);
+    }
+    /**
+     * Highlights the last item out of all items.
+     * @returns The highlighted item.
+     */
+    highlightLastItem() {
+        this.unhighlightAll();
+        let itemToHighlight = this._getHiglightableItems().last().index;
+        return this.highlightItem(itemToHighlight);
+    }
+    /**
+     * Highlights all non-disabled items.
+     */
+    highlightAllItems() {
+        let itemsToHighlight = this._getHiglightableItems().map(v => v.index);
+        this.highlightItem(...itemsToHighlight);
+    }
+    /**
+     * Highlights the next non-disabled item defined by the offset amount.
+     *
+     * If `hasShift` is set to true, all originally highlighted items are kept. Otherwise, all original items are unselected.
+     * @param offset The amount of items to offset the highlight by.
+     * @param hasShift Whether the user has the shift key pressed.
+     * @returns The item highlighted.
+     */
+    highlightNextItem(offset, hasShift) {
+        if (!this.isAnyItemHighlighted) {
+            return this.highlightFirstItem();
+        }
+        const currentItem = this.highlightedItems.last();
+        const itemsWithoutDisabled = this._items.filter(item => !item.disabled && (!this.isItemLimitReached || item.selected));
+        const currentIndexInItems = itemsWithoutDisabled.findIndex(item => item.index == currentItem.index);
+        let nextItemIndex = currentIndexInItems + offset;
+        if (nextItemIndex >= itemsWithoutDisabled.length) {
+            nextItemIndex -= itemsWithoutDisabled.length;
+        }
+        if (nextItemIndex < 0) {
+            nextItemIndex += itemsWithoutDisabled.length;
+        }
+        const itemToHighlight = itemsWithoutDisabled[nextItemIndex];
+        if (hasShift) {
+            if (itemToHighlight.highlighted) {
+                this.unhighlightItem(nextItemIndex);
+            }
+            return this.highlightItem(nextItemIndex);
+        }
+        return this.highlightSingleItem(nextItemIndex);
+    }
+    /**
+     * Finds all highlightable items. An item is considered highlightable if it is **not** disabled.
+     * @returns An array of all highlightable items.
+     */
+    _getHiglightableItems() {
+        return this._items.filter(item => !item.disabled);
+    }
+    toggleCurrentSortColumn(column) {
+        if (this._currentSortColumn == column) {
+            if (this._currentSortType == SortType.Ascending) {
+                this._currentSortType = SortType.Descending;
+            }
+            else {
+                this._currentSortType = SortType.Ascending;
+            }
+            this._generateSortedRows(true);
+            return;
+        }
+        this._currentSortColumn = column;
+        this._currentSortType = SortType.Ascending;
+        this._generateSortedRows();
+    }
+    resetSort() {
+        this._currentSortColumn = null;
+        this._currentSortType = null;
+        this._sortedItems = [...this.items];
+    }
+    getColumnSortType(column) {
+        if (this._currentSortColumn == column) {
+            return this._currentSortType;
+        }
+        return null;
+    }
+    _generateSortedRows(justReverse) {
+        if (justReverse) {
+            this._sortedItems.reverse();
+            return;
+        }
+        const sortColumnIndex = this._currentSortColumn;
+        if (isNull(sortColumnIndex) || !this._currentSortType) {
+            this._sortedItems = this.items;
+            return;
+        }
+        const sortColumn = this._dataColumns[sortColumnIndex];
+        if (!sortColumn) {
+            throw new Error(`Encountered an issue in <ard-table>: could not find the column with index ${sortColumnIndex}. This is most likely an Ardium bug, please report it on GitHub.`);
+        }
+        const direction = this._currentSortType == SortType.Ascending ? 1 : -1;
+        const sortFn = sortColumn.sortFn ??
+            ((a, b) => {
+                if (a > b)
+                    return direction;
+                if (a < b)
+                    return -1 * direction;
+                return 0;
+            });
+        this._sortedItems = [...this.items].sort((a, b) => sortFn(a.data[sortColumnIndex], b.data[sortColumnIndex]));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-item-storage.js","sourceRoot":"","sources":["../../../../../projects/ui/src/lib/table/table-item-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import resolvePath from 'resolve-object-path';\nimport { evaluate, isDefined, isNull } from 'simple-bool';\nimport { CompareWithFn } from '../types/item-storage.types';\nimport { SortType, TableDataColumn, TablePaginationStrategy, TableSubheader } from './table.types';\nimport { areAllDataColumns, isTableSubheader, merge2dArrays } from './utils';\n\nexport interface ArdTableRow {\n    readonly itemData: any;\n    readonly index: number;\n    readonly isEmpty?: boolean;\n    data: any[];\n    dataColumns: TableDataColumn[];\n    class?: string;\n    disabled?: boolean;\n    bold?: boolean;\n    selected?: boolean;\n    highlighted?: boolean;\n}\nexport interface TableItemStorageHostDefaults {\n    rowDisabledFrom: string;\n    rowBoldFrom: string;\n}\nexport interface TableItemStorageHost {\n    rowDisabledFrom?: string;\n    rowBoldFrom?: string;\n    invertRowDisabled?: boolean;\n    invertRowBold?: boolean;\n    data?: any[];\n    readonly DEFAULTS: TableItemStorageHostDefaults;\n    maxSelectedItems?: number;\n    treatDataSourceAsString?: boolean;\n\n    paginated: boolean;\n    paginationStrategy: TablePaginationStrategy;\n    itemsPerPage: number;\n    page: number;\n}\nexport class HeaderCell {\n    colspan!: number;\n    rowspan!: number;\n    cell!: TableDataColumn | TableSubheader;\n\n    get width(): string | null {\n        if (isTableSubheader(this.cell)) return null;\n        return this._getWidth(this.cell.width);\n    }\n    get minWidth(): string | null {\n        if (isTableSubheader(this.cell)) return null;\n        return this._getWidth(this.cell.minWidth);\n    }\n    private _getWidth(width: string | number | undefined): string | null {\n        if (!width) return null;\n        if (typeof width == 'number') return `${width}px`;\n        return width;\n    }\n\n    constructor(cell: TableDataColumn | TableSubheader, colspan: number = 1, rowspan: number = 1) {\n        this.cell = cell;\n        this.colspan = colspan;\n        this.rowspan = rowspan;\n    }\n}\n\nexport class TableItemStorage {\n    private _items: ArdTableRow[] = [];\n    private _sortedItems: ArdTableRow[] = [];\n    private _highlightedItems: ArdTableRow[] = [];\n    private _selectedItems: ArdTableRow[] = [];\n\n    private _dataColumns: TableDataColumn[] = [];\n    private _headerCells: HeaderCell[][] = [];\n\n    constructor(private _ardParentComp: TableItemStorageHost) {}\n\n    /**\n     * Gets all items.\n     */\n    get items(): ArdTableRow[] {\n        return this._items;\n    }\n    get sortedItems(): ArdTableRow[] {\n        return this._sortedItems;\n    }\n    /**\n     * Gets items based on the current pagination state.\n     */\n    get paginatedItems(): ArdTableRow[] {\n        //prettier-ignore\n        if (\n            !this._ardParentComp.paginated\n            || this._ardParentComp.paginationStrategy == TablePaginationStrategy.Noop\n        ) {\n            return this.sortedItems;\n        }\n        const page = this._ardParentComp.page;\n        const IPP = this._ardParentComp.itemsPerPage;\n        const itemsStart = (page - 1) * IPP;\n        const itemsEnd = page * IPP;\n        return this.sortedItems.slice(itemsStart, itemsEnd);\n    }\n    /**\n     * Gets all currently selected items.\n     */\n    get selectedItems(): ArdTableRow[] {\n        return this._selectedItems;\n    }\n    /**\n     * Gets all currently highlighted items.\n     */\n    get highlightedItems(): ArdTableRow[] {\n        return this._highlightedItems;\n    }\n    /**\n     * Gets the values of the currently selected items.\n     */\n    get value(): any[] {\n        return this._itemsToValue(this.selectedItems);\n    }\n    /**\n     * Maps an array of items into their values.\n     * @param items The items to convert to value.\n     * @returns An array of item values.\n     */\n    private _itemsToValue(items: ArdTableRow[]): any[] {\n        return items.map(item => item.itemData);\n    }\n\n    /**\n     * Returns true if at least one item is highlighted, otherwise false.\n     */\n    get isAnyItemHighlighted(): boolean {\n        return this._highlightedItems.length > 0;\n    }\n    /**\n     * Checks if any item in the table is selected.\n     * @returns A boolean value indicating if any item is selected.\n     */\n    get isAnyItemSelected(): boolean {\n        return this._selectedItems.length > 0;\n    }\n    /**\n     * Checks if all items in the table are selected.\n     * @returns A boolean value indicating if all items are selected.\n     */\n    get areAllSelected(): boolean {\n        return this._selectedItems.length == this._items.filter(item => !item.disabled).length;\n    }\n    /**\n     * Returns true if the parent component defines the limit of concurrently selectable items and the amount of currently selected items matches that limit. Otherwise returns false.\n     *\n     * **TLDR**: true if `maxSelectedItems` is defined and the number of selected items matches that value.\n     */\n    get isItemLimitReached(): boolean {\n        if (!isDefined(this._ardParentComp.maxSelectedItems)) {\n            return false;\n        }\n        return this._ardParentComp.maxSelectedItems <= this.selectedItems.length;\n    }\n\n    /**\n     * Gets the header cells of the table.\n     * @returns a 2D array of header cells.\n     */\n    get headerCells(): HeaderCell[][] {\n        return this._headerCells;\n    }\n    /**\n     * Checks if the table has defined columns.\n     * @returns a boolean value indicating if the table has defined columns.\n     */\n    get hasDefinedColumns(): boolean {\n        return this._dataColumns.length > 0;\n    }\n\n    //! setting columns\n    /**\n     * Sets the columns of the table.\n     * @param cols an array of table data columns or table subheaders.\n     */\n    setColumns(cols: (TableDataColumn | TableSubheader)[]): void {\n        const maxNestingLevel = this._getHeaderMaxNesting(cols);\n        const headerCells = this._mapColumnsToArray(cols, maxNestingLevel, 0);\n        this._headerCells = this._filterHeaderCells(headerCells);\n        this._dataColumns = this._extractDataSources(cols);\n    }\n    /**\n     * Filters out null values from the header cells array.\n     * @param cells a 2D array of header cells or null values.\n     * @returns a 2D array of header cells without null values and empty arrays.\n     */\n    private _filterHeaderCells(cells: (HeaderCell | null)[][]): HeaderCell[][] {\n        for (let i = 0; i < cells.length; i++) {\n            cells[i] = cells[i].filter(v => v != null);\n        }\n        return cells.filter(row => row.length) as HeaderCell[][];\n    }\n    /**\n     * Extracts the data sources from the columns array.\n     * @param cols an array of table data columns or table subheaders.\n     * @returns an array of table data columns.\n     */\n    private _extractDataSources(cols: (TableDataColumn | TableSubheader)[]): TableDataColumn[] {\n        let dataColumns: TableDataColumn[] = [];\n\n        for (const col of cols) {\n            if (!isTableSubheader(col)) {\n                dataColumns.push(col);\n                continue;\n            }\n            dataColumns.push(...this._extractDataSources(col.children));\n        }\n\n        return dataColumns;\n    }\n    /**\n     * Gets the maximum nesting level of the columns array.\n     * @param cols an array of table data columns or table subheaders.\n     * @returns the maximum nesting level as a number.\n     */\n    private _getHeaderMaxNesting(cols: (TableDataColumn | TableSubheader)[]): number {\n        if (areAllDataColumns(cols)) return 1;\n        let max = 1;\n        for (const col of cols.filter(v => isTableSubheader(v)) as TableSubheader[]) {\n            const height = 1 + this._getHeaderMaxNesting(col.children);\n            if (height > max) max = height;\n        }\n        return max;\n    }\n    /**\n     * Maps the columns tree to a 2D array of header cells or null values.\n     * @param cols an array of table data columns or table subheaders.\n     * @param maxNesting the maximum nesting level of the columns array.\n     * @param currentNesting the current nesting level of the columns array.\n     * @returns a 2D array of header cells or null values.\n     */\n    private _mapColumnsToArray(cols: (TableDataColumn | TableSubheader)[], maxNesting: number, currentNesting: number): (HeaderCell | null)[][] {\n        if (areAllDataColumns(cols)) {\n            return [cols.map(col => new HeaderCell(col, 1, maxNesting - currentNesting))];\n        }\n        const headerCells: (HeaderCell | null)[][] = [[]];\n        for (const col of cols) {\n            if (!isTableSubheader(col)) {\n                headerCells[0].push(new HeaderCell(col, 1, maxNesting - currentNesting));\n                continue;\n            }\n            const childCells: (HeaderCell | null)[][] = [[], ...this._mapColumnsToArray(col.children, maxNesting, currentNesting + 1)];\n            const height = childCells.length - 1;\n            const width = childCells[1].length;\n            for (let i = 0; i < height; i++) {\n                headerCells.push([null]);\n            }\n            headerCells[0].push(new HeaderCell(col, width, 1));\n            for (let i = 0; i < width - 1; i++) {\n                headerCells[0].push(null);\n            }\n            merge2dArrays(headerCells, childCells);\n        }\n        return headerCells;\n    }\n\n    //! setting items\n    /**\n     * Sets the component's items. Takes into account the values defined by the parent component for `rowDisabledFrom`, `rowBoldFrom`, and `rowHighlightedFrom`.\n     * @param items An array of items to be set as the component's items.\n     */\n    setItems(items: any[]): void {\n        if (!this.hasDefinedColumns) return;\n\n        this._items = items.map((item, index) => {\n            return this._setItemsMapFn(item, index);\n        });\n        this._sortedItems = this._items;\n    }\n    /**\n     * Maps raw item data to an {@link ArdTableRow} object.\n     *\n     * @param {any} rawItemData - The raw data of the item.\n     * @param {number} index - The index of the item.\n     * @returns {ArdTableRow} Returns an ArdTableRow object with mapped properties.\n     * @private\n     */\n    private _setItemsMapFn(rawItemData: any, index: number): ArdTableRow {\n        //get data\n        const [data, dataColumns] = this._getRowData(rawItemData, index);\n\n        //get bold\n        const rowBoldFromPath = this._ardParentComp.rowBoldFrom ?? this._ardParentComp.DEFAULTS.rowBoldFrom;\n        let bold = resolvePath(rawItemData, rowBoldFromPath);\n        if (this._ardParentComp.invertRowBold) {\n            bold = !bold;\n        }\n\n        //get disabled\n        const disabledPath = this._ardParentComp.rowDisabledFrom ?? this._ardParentComp.DEFAULTS.rowDisabledFrom;\n        let disabled = evaluate(resolvePath(rawItemData, disabledPath));\n        if (this._ardParentComp.invertRowDisabled) {\n            disabled = !disabled;\n        }\n\n        //return\n        return {\n            itemData: rawItemData,\n            index,\n            data,\n            dataColumns,\n            disabled,\n            bold,\n        };\n    }\n    /**\n     * Retrieves data for a row based on data columns configuration.\n     *\n     * @param {any} rawItemData - The raw data of the item.\n     * @param {number} index - The index of the item.\n     * @returns {any[]} Returns an array containing the row data.\n     * @private\n     */\n    private _getRowData(rawItemData: any, index: number): [any[], TableDataColumn[]] {\n        let data: any[] = [];\n        for (const dataColumn of this._dataColumns) {\n            const sourcePath = dataColumn.dataSource;\n\n            if (typeof sourcePath == 'string') {\n                if (this._ardParentComp.treatDataSourceAsString) {\n                    data.push(rawItemData[sourcePath]);\n                    continue;\n                }\n                data.push(resolvePath(rawItemData, sourcePath));\n                continue;\n            }\n            if (sourcePath.type == 'autocount') {\n                data.push(index + 1);\n                continue;\n            }\n            if (sourcePath.type == 'checkbox') {\n                data.push({ _ardCheckbox: true, index });\n                continue;\n            }\n            const sourceString = typeof sourcePath == 'object' ? JSON.stringify(sourcePath) : sourcePath;\n            console.error(new Error(`Unexpected data source \"${sourceString}\".`));\n        }\n        return [data, this._dataColumns];\n    }\n    /**\n     * Writes a new value to the item storage. Selects the correct items based on the provided values, warning the user if the value is not found.\n     * @param indexes The value of the ngModel to set.\n     */\n    writeValue(indexes: number[]): void {\n        this._forceUnselectAll();\n        this.selectItem(...indexes);\n    }\n\n    //! selecting items\n    /**\n     * Checks if an item with the given index is selected.\n     *\n     * @param {number} index The index of the item to check.\n     * @returns {boolean} _true_ if the item is selected, otherwise _false_.\n     */\n    isItemSelected(index: number): boolean {\n        return this._selectedItems.some(item => item.index == index);\n    }\n    /**\n     * Selects all items.\n     *\n     * Accounts for the limit of concurrently selected items defined by the parent component.\n     * @returns a tuple containing two arrays:\n     * * An array of items selected.\n     * * An array of items failed to select.\n     */\n    selectAll(): [any[], any[]] {\n        return this.selectItem(...this._items.map(v => v.index));\n    }\n    /**\n     * Unselects all selected items.\n     *\n     * If the parent component requires at least one value to be selected at all times, the first selected items is left selected.\n     * @returns An array of items cleared, mapped to only their values.\n     */\n    unselectAll(): any[] {\n        for (const item of this._selectedItems) {\n            item.selected = false;\n        }\n\n        const ret = this._itemsToValue(this._selectedItems);\n\n        this._selectedItems = [];\n\n        return ret;\n    }\n    /**\n     * Unselects all selected items, no matter what the component settings are.\n     * @returns An array of items cleared, mapped to only their values.\n     */\n    private _forceUnselectAll(): any[] {\n        for (const item of this._selectedItems) {\n            item.selected = false;\n        }\n\n        const ret = this._itemsToValue(this._selectedItems);\n\n        this._selectedItems = [];\n\n        return ret;\n    }\n    /**\n     * Selects one or multiple items.\n     *\n     * Accounts for the limit of concurrently selected items defined by the parent component.\n     *\n     * @param indexes A rest operator array of item indexes to be selected.\n     * @returns a tuple containing two arrays:\n     * * An array of items selected.\n     * * An array of items failed to select.\n     */\n    selectItem(...indexes: number[]): [any[], any[]] {\n        const itemsToBeSelected = this._items.filter(item => !item.disabled && indexes.includes(item.index));\n        if (this.isItemLimitReached) {\n            return [[], this._itemsToValue(itemsToBeSelected)];\n        }\n\n        let itemsSelectedCount = 0;\n        const itemsSelected = [];\n        for (const item of itemsToBeSelected) {\n            itemsSelectedCount++;\n            if (item.selected) continue;\n            if (this.isItemLimitReached) {\n                break;\n            }\n            item.selected = true;\n            this._selectedItems.push(item);\n            itemsSelected.push(item);\n        }\n\n        const itemsFailedToSelect = itemsToBeSelected.slice(itemsSelectedCount - 1);\n        return [this._itemsToValue(itemsSelected), this._itemsToValue(itemsFailedToSelect)];\n    }\n    /**\n     * Unselects one or multiple items.\n     * @param items A rest operator array of item indexes to be unselected.\n     * @returns An array of items unselected, mapped to only their values.\n     */\n    unselectItem(...indexes: number[]): any[] {\n        const itemsToBeSelected = this._items.filter(item => indexes.includes(item.index));\n        for (const item of itemsToBeSelected) {\n            item.selected = false;\n        }\n        this._selectedItems = this._selectedItems.filter(v => v.selected);\n\n        return this._itemsToValue(itemsToBeSelected);\n    }\n\n    //! highlighting items\n    /**\n     * Unhighlights all currently highlighted items.\n     */\n    unhighlightAll(): void {\n        for (const item of this._highlightedItems) {\n            item.highlighted = false;\n        }\n        this._highlightedItems = [];\n    }\n    /**\n     * Highlights the given item, while unhighlighting all other items. Does nothing when the item is disabled.\n     * @param item The index of the item to be highlighted.\n     * @returns The highlighted item.\n     */\n    highlightSingleItem(index: number): ArdTableRow | null {\n        this.unhighlightAll();\n        return this.highlightItem(index);\n    }\n    /**\n     * Highlights all given items.\n     * @param items A rest operator array of item indexes to be highlighted.\n     * @returns The last highlighted item.\n     */\n    highlightItem(...indexes: number[]): ArdTableRow {\n        const items = this._items.filter(item => indexes.includes(item.index));\n        for (const item of items) {\n            item.highlighted = true;\n        }\n        this._highlightedItems.push(...items);\n        return items.last();\n    }\n    /**\n     * Unhighlights all given items.\n     * @param items A rest operator array of item indexes to be unhighlighted.\n     */\n    unhighlightItem(...indexes: number[]): void {\n        const items = this._items.filter(item => indexes.includes(item.index));\n        for (const item of items) {\n            if (!item || !item.highlighted) return;\n\n            item.highlighted = false;\n        }\n        this._highlightedItems = this._highlightedItems.filter(v => v.highlighted);\n    }\n    /**\n     * Highlights the first item out of all items.\n     * @returns The highlighted item.\n     */\n    highlightFirstItem(): ArdTableRow | null {\n        this.unhighlightAll();\n\n        let itemToHighlight = this._getHiglightableItems().first().index;\n        return this.highlightItem(itemToHighlight);\n    }\n    /**\n     * Highlights the last item out of all items.\n     * @returns The highlighted item.\n     */\n    highlightLastItem(): ArdTableRow | null {\n        this.unhighlightAll();\n\n        let itemToHighlight = this._getHiglightableItems().last().index;\n        return this.highlightItem(itemToHighlight);\n    }\n    /**\n     * Highlights all non-disabled items.\n     */\n    highlightAllItems(): void {\n        let itemsToHighlight = this._getHiglightableItems().map(v => v.index);\n\n        this.highlightItem(...itemsToHighlight);\n    }\n    /**\n     * Highlights the next non-disabled item defined by the offset amount.\n     *\n     * If `hasShift` is set to true, all originally highlighted items are kept. Otherwise, all original items are unselected.\n     * @param offset The amount of items to offset the highlight by.\n     * @param hasShift Whether the user has the shift key pressed.\n     * @returns The item highlighted.\n     */\n    highlightNextItem(offset: number, hasShift?: boolean): ArdTableRow | null {\n        if (!this.isAnyItemHighlighted) {\n            return this.highlightFirstItem();\n        }\n        const currentItem = this.highlightedItems.last();\n        const itemsWithoutDisabled = this._items.filter(item => !item.disabled && (!this.isItemLimitReached || item.selected));\n        const currentIndexInItems = itemsWithoutDisabled.findIndex(item => item.index == currentItem.index);\n\n        let nextItemIndex = currentIndexInItems + offset;\n        if (nextItemIndex >= itemsWithoutDisabled.length) {\n            nextItemIndex -= itemsWithoutDisabled.length;\n        }\n        if (nextItemIndex < 0) {\n            nextItemIndex += itemsWithoutDisabled.length;\n        }\n        const itemToHighlight = itemsWithoutDisabled[nextItemIndex];\n\n        if (hasShift) {\n            if (itemToHighlight.highlighted) {\n                this.unhighlightItem(nextItemIndex);\n            }\n            return this.highlightItem(nextItemIndex);\n        }\n        return this.highlightSingleItem(nextItemIndex);\n    }\n    /**\n     * Finds all highlightable items. An item is considered highlightable if it is **not** disabled.\n     * @returns An array of all highlightable items.\n     */\n    private _getHiglightableItems(): ArdTableRow[] {\n        return this._items.filter(item => !item.disabled);\n    }\n\n    //! sorting\n    private _currentSortColumn: number | null = null;\n    private _currentSortType: SortType | null = null;\n\n    toggleCurrentSortColumn(column: number): void {\n        if (this._currentSortColumn == column) {\n            if (this._currentSortType == SortType.Ascending) {\n                this._currentSortType = SortType.Descending;\n            } else {\n                this._currentSortType = SortType.Ascending;\n            }\n            this._generateSortedRows(true);\n            return;\n        }\n        this._currentSortColumn = column;\n        this._currentSortType = SortType.Ascending;\n        this._generateSortedRows();\n    }\n    resetSort(): void {\n        this._currentSortColumn = null;\n        this._currentSortType = null;\n        this._sortedItems = [...this.items];\n    }\n    getColumnSortType(column: number): SortType | null {\n        if (this._currentSortColumn == column) {\n            return this._currentSortType;\n        }\n        return null;\n    }\n    private _generateSortedRows(justReverse?: boolean): void {\n        if (justReverse) {\n            this._sortedItems.reverse();\n            return;\n        }\n        const sortColumnIndex = this._currentSortColumn;\n        if (isNull(sortColumnIndex) || !this._currentSortType) {\n            this._sortedItems = this.items;\n            return;\n        }\n        const sortColumn = this._dataColumns[sortColumnIndex];\n        if (!sortColumn) {\n            throw new Error(\n                `Encountered an issue in <ard-table>: could not find the column with index ${sortColumnIndex}. This is most likely an Ardium bug, please report it on GitHub.`\n            );\n        }\n\n        const direction = this._currentSortType == SortType.Ascending ? 1 : -1;\n        const sortFn =\n            sortColumn.sortFn ??\n            ((a, b) => {\n                if (a > b) return direction;\n                if (a < b) return -1 * direction;\n                return 0;\n            });\n\n        this._sortedItems = [...this.items].sort((a, b) => sortFn(a.data[sortColumnIndex], b.data[sortColumnIndex]));\n    }\n}\n"]}