@hmcts/opal-frontend-common 0.0.108 → 0.0.110

package/fesm2022/hmcts-opal-frontend-common-components-abstract-abstract-sortable-table-pagination.mjs

@@ -1,130 +1,105 @@
-import * as i0 from '@angular/core';
-import { inject, Injector, effect, signal, computed, afterNextRender, ElementRef, Input, ViewChildren, Component } from '@angular/core';
-import { AbstractSortableTableComponent } from '@hmcts/opal-frontend-common/components/abstract/abstract-sortable-table';
-import { UtilsService } from '@hmcts/opal-frontend-common/services/utils-service';
-
-class AbstractSortableTablePaginationComponent extends AbstractSortableTableComponent {
-    injector = inject(Injector);
-    paginationFocusUtilsService = inject(UtilsService);
-    paginationFocusTargets;
-    /**
-     * Keeps the current page within the available range when the data set or page size changes.
-     */
-    clampCurrentPageEffect = effect(() => {
-        const totalPages = Math.max(1, Math.ceil(this.sortedTableDataSignal().length / this.itemsPerPageSignal()));
-        if (this.currentPageSignal() > totalPages) {
-            this.currentPageSignal.set(totalPages);
-        }
-    }, ...(ngDevMode ? [{ debugName: "clampCurrentPageEffect" }] : /* istanbul ignore next */ []));
-    // Signal for the current page. Used to calculate the start and end indices for pagination.
-    currentPageSignal = signal(1, ...(ngDevMode ? [{ debugName: "currentPageSignal" }] : /* istanbul ignore next */ []));
-    // Signal for the number of items per page. Determines how many items are displayed on each page.
-    itemsPerPageSignal = signal(10, ...(ngDevMode ? [{ debugName: "itemsPerPageSignal" }] : /* istanbul ignore next */ []));
-    // Optional page title included in the announcement exposed to the consuming template.
-    paginationPageTitle = '';
-    // Announcement for a consuming template to render in a live status region.
-    pageChangeAnnouncement = signal('', ...(ngDevMode ? [{ debugName: "pageChangeAnnouncement" }] : /* istanbul ignore next */ []));
-    // Signal for the start index (1-based). Automatically updates when `currentPageSignal` or `itemsPerPageSignal` changes.
-    startIndexComputed = computed(() => {
-        const currentPage = this.currentPageSignal();
-        return (currentPage - 1) * this.itemsPerPageSignal() + 1;
-    }, ...(ngDevMode ? [{ debugName: "startIndexComputed" }] : /* istanbul ignore next */ []));
-    /**
-     * Computes the end index for the current page of the sorted table data.
-     * Ensures the end index does not exceed the total number of items.
-     *
-     * @returns The zero-based index of the last item to display on the current page.
-     */
-    endIndexComputed = computed(() => {
-        return Math.min(this.sortedTableDataSignal().length, this.startIndexComputed() + this.itemsPerPageSignal() - 1);
-    }, ...(ngDevMode ? [{ debugName: "endIndexComputed" }] : /* istanbul ignore next */ []));
-    // Computed signal for paginated table data. Reactively slices `displayTableDataSignal` based on `startIndexComputed` and `endIndexComputed`.
-    paginatedTableDataComputed = computed(() => {
-        const data = this.sortedTableDataSignal(); // Full table data
-        return data.slice(this.startIndexComputed() - 1, this.endIndexComputed()); // Return paginated data subset
-    }, ...(ngDevMode ? [{ debugName: "paginatedTableDataComputed" }] : /* istanbul ignore next */ []));
-    /**
-     * Focuses the first target rendered for the new page and lets the browser scroll it into view.
-     * Falls back to the main content landmark when the table has no marked focus target.
-     */
-    focusNewPageContent() {
-        const focusTarget = this.paginationFocusTargets.first?.nativeElement;
-        if (focusTarget) {
-            const hasTabindex = focusTarget.hasAttribute('tabindex');
-            if (!hasTabindex) {
-                focusTarget.setAttribute('tabindex', '-1');
-                focusTarget.addEventListener('blur', () => focusTarget.removeAttribute('tabindex'), { once: true });
-            }
-            focusTarget.focus();
-            return;
-        }
-        this.paginationFocusUtilsService.focusAndScrollToTop();
-    }
-    /**
-     * Handles sorting changes and resets the page to the first page.
-     *
-     * @param event - The sorting event containing:
-     *   - `key`: The column key to sort by.
-     *   - `sortType`: The sorting order, either 'ascending' or 'descending'.
-     *
-     * Resets `currentPageSignal` to 1 and triggers re-sorting of `displayTableDataSignal`.
-     */
-    onSortChange(event) {
-        super.onSortChange(event); // Update the sort state and sort the data
-        this.currentPageSignal.set(1); // Reset the page to the first page
-    }
-    /**
-     * Applies the current filters to the table data.
-     *
-     * Overrides the base implementation to additionally reset the pagination to the first page
-     * after filters are applied.
-     *
-     * @override
-     */
-    onApplyFilters() {
-        super.onApplyFilters();
-        this.currentPageSignal.set(1); // Reset to first page after filtering
-    }
-    /**
-     * Handles the event when the page is changed.
-     * Moves focus to the first marked target, or the main content fallback, after committing a different page.
-     *
-     * @param newPage - The new page number to set. If the provided page number is out of range,
-     * it will be clamped between 1 and the total number of pages.
-     */
-    onPageChange(newPage) {
-        const totalPages = Math.ceil(this.sortedTableDataSignal().length / this.itemsPerPageSignal());
-        const nextPage = Math.max(1, Math.min(newPage, totalPages));
-        if (nextPage === this.currentPageSignal()) {
-            return;
-        }
-        const pageTitle = this.paginationPageTitle.trim();
-        const pageContext = `${nextPage} of ${totalPages}`;
-        this.pageChangeAnnouncement.set(pageTitle ? `${pageTitle}, page ${pageContext}` : `Page ${pageContext}`);
-        this.currentPageSignal.set(nextPage);
-        afterNextRender({
-            mixedReadWrite: () => this.focusNewPageContent(),
-        }, { injector: this.injector });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.21", ngImport: i0, type: AbstractSortableTablePaginationComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.21", type: AbstractSortableTablePaginationComponent, isStandalone: true, selector: "ng-component", inputs: { paginationPageTitle: "paginationPageTitle" }, viewQueries: [{ propertyName: "paginationFocusTargets", predicate: ["paginationFocusTarget"], descendants: true, read: ElementRef }], usesInheritance: true, ngImport: i0, template: '', isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.21", ngImport: i0, type: AbstractSortableTablePaginationComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: '',
-                }]
-        }], propDecorators: { paginationFocusTargets: [{
-                type: ViewChildren,
-                args: ['paginationFocusTarget', { read: ElementRef }]
-            }], paginationPageTitle: [{
-                type: Input,
-                args: [{ required: false }]
-            }] } });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+import * as i0 from "@angular/core";
+import { Component, ElementRef, Injector, Input, ViewChildren, afterNextRender, computed, effect, inject, signal } from "@angular/core";
+import { AbstractSortableTableComponent } from "@hmcts/opal-frontend-common/components/abstract/abstract-sortable-table";
+import { UtilsService } from "@hmcts/opal-frontend-common/services/utils-service";
+var AbstractSortableTablePaginationComponent = class AbstractSortableTablePaginationComponent extends AbstractSortableTableComponent {
+	injector = inject(Injector);
+	paginationFocusUtilsService = inject(UtilsService);
+	paginationFocusTargets;
+	clampCurrentPageEffect = effect(() => {
+		const totalPages = Math.max(1, Math.ceil(this.sortedTableDataSignal().length / this.itemsPerPageSignal()));
+		if (this.currentPageSignal() > totalPages) this.currentPageSignal.set(totalPages);
+	}, ...ngDevMode ? [{ debugName: "clampCurrentPageEffect" }] : /* istanbul ignore next */ []);
+	currentPageSignal = signal(1, ...ngDevMode ? [{ debugName: "currentPageSignal" }] : /* istanbul ignore next */ []);
+	itemsPerPageSignal = signal(10, ...ngDevMode ? [{ debugName: "itemsPerPageSignal" }] : /* istanbul ignore next */ []);
+	paginationPageTitle = "";
+	pageChangeAnnouncement = signal("", ...ngDevMode ? [{ debugName: "pageChangeAnnouncement" }] : /* istanbul ignore next */ []);
+	startIndexComputed = computed(() => {
+		return (this.currentPageSignal() - 1) * this.itemsPerPageSignal() + 1;
+	}, ...ngDevMode ? [{ debugName: "startIndexComputed" }] : /* istanbul ignore next */ []);
+	endIndexComputed = computed(() => {
+		return Math.min(this.sortedTableDataSignal().length, this.startIndexComputed() + this.itemsPerPageSignal() - 1);
+	}, ...ngDevMode ? [{ debugName: "endIndexComputed" }] : /* istanbul ignore next */ []);
+	paginatedTableDataComputed = computed(() => {
+		return this.sortedTableDataSignal().slice(this.startIndexComputed() - 1, this.endIndexComputed());
+	}, ...ngDevMode ? [{ debugName: "paginatedTableDataComputed" }] : /* istanbul ignore next */ []);
+	focusNewPageContent() {
+		const focusTarget = this.paginationFocusTargets.first?.nativeElement;
+		if (focusTarget) {
+			if (!focusTarget.hasAttribute("tabindex")) {
+				focusTarget.setAttribute("tabindex", "-1");
+				focusTarget.addEventListener("blur", () => focusTarget.removeAttribute("tabindex"), { once: true });
+			}
+			focusTarget.focus();
+			return;
+		}
+		this.paginationFocusUtilsService.focusAndScrollToTop();
+	}
+	onSortChange(event) {
+		super.onSortChange(event);
+		this.currentPageSignal.set(1);
+	}
+	onApplyFilters() {
+		super.onApplyFilters();
+		this.currentPageSignal.set(1);
+	}
+	onPageChange(newPage) {
+		const totalPages = Math.ceil(this.sortedTableDataSignal().length / this.itemsPerPageSignal());
+		const nextPage = Math.max(1, Math.min(newPage, totalPages));
+		if (nextPage === this.currentPageSignal()) return;
+		const pageTitle = this.paginationPageTitle.trim();
+		const pageContext = `${nextPage} of ${totalPages}`;
+		this.pageChangeAnnouncement.set(pageTitle ? `${pageTitle}, page ${pageContext}` : `Page ${pageContext}`);
+		this.currentPageSignal.set(nextPage);
+		afterNextRender({ mixedReadWrite: () => this.focusNewPageContent() }, { injector: this.injector });
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "21.2.25",
+		ngImport: i0,
+		type: AbstractSortableTablePaginationComponent,
+		deps: null,
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "14.0.0",
+		version: "21.2.25",
+		type: AbstractSortableTablePaginationComponent,
+		isStandalone: true,
+		selector: "ng-component",
+		inputs: { paginationPageTitle: "paginationPageTitle" },
+		viewQueries: [{
+			propertyName: "paginationFocusTargets",
+			predicate: ["paginationFocusTarget"],
+			descendants: true,
+			read: ElementRef
+		}],
+		usesInheritance: true,
+		ngImport: i0,
+		template: "",
+		isInline: true
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "21.2.25",
+	ngImport: i0,
+	type: AbstractSortableTablePaginationComponent,
+	decorators: [{
+		type: Component,
+		args: [{ template: "" }]
+	}],
+	propDecorators: {
+		paginationFocusTargets: [{
+			type: ViewChildren,
+			args: ["paginationFocusTarget", { read: ElementRef }]
+		}],
+		paginationPageTitle: [{
+			type: Input,
+			args: [{ required: false }]
+		}]
+	}
+});
 export { AbstractSortableTablePaginationComponent };
-//# sourceMappingURL=hmcts-opal-frontend-common-components-abstract-abstract-sortable-table-pagination.mjs.map
+
+//# sourceMappingURL=hmcts-opal-frontend-common-components-abstract-abstract-sortable-table-pagination.mjs.map

package/fesm2022/hmcts-opal-frontend-common-components-abstract-abstract-sortable-table-types.mjs

@@ -1,4 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-//# sourceMappingURL=hmcts-opal-frontend-common-components-abstract-abstract-sortable-table-types.mjs.map

package/fesm2022/hmcts-opal-frontend-common-components-abstract-abstract-sortable-table.mjs

@@ -1,205 +1,124 @@
-import * as i0 from '@angular/core';
-import { inject, effect, signal, EventEmitter, Output, Component } from '@angular/core';
-import { SortService } from '@hmcts/opal-frontend-common/services/sort-service';
-import { AbstractTableFilterComponent } from '@hmcts/opal-frontend-common/components/abstract/abstract-table-filter';
-
-class AbstractSortableTableComponent extends AbstractTableFilterComponent {
-    sortService = inject(SortService);
-    /**
-     * Synchronizes the sorted table data with the current filter and sort state.
-     *
-     * This effect observes changes to the filtered table data and the sort state signals.
-     * If no active sort key is found (i.e., no sorting is applied), it sets the sorted table data
-     * to a shallow copy of the filtered data. Otherwise, sorting logic should be applied elsewhere.
-     *
-     * @protected
-     */
-    syncSortedDataEffect = effect(() => {
-        const filtered = this.filteredTableDataSignal();
-        const currentSort = this.sortStateSignal();
-        const activeSortKey = Object.keys(currentSort).some((k) => currentSort[k] !== 'none');
-        if (!activeSortKey) {
-            // No sort applied – use filtered data directly
-            this.sortedTableDataSignal.set([...filtered]);
-        }
-    }, ...(ngDevMode ? [{ debugName: "syncSortedDataEffect" }] : /* istanbul ignore next */ []));
-    displayTableDataSignal = signal([], ...(ngDevMode ? [{ debugName: "displayTableDataSignal" }] : /* istanbul ignore next */ []));
-    filteredTableDataSignal = signal([], ...(ngDevMode ? [{ debugName: "filteredTableDataSignal" }] : /* istanbul ignore next */ []));
-    sortedTableDataSignal = signal([], ...(ngDevMode ? [{ debugName: "sortedTableDataSignal" }] : /* istanbul ignore next */ []));
-    abstractExistingSortState = null;
-    sortStateSignal = signal({}, ...(ngDevMode ? [{ debugName: "sortStateSignal" }] : /* istanbul ignore next */ []));
-    sortedColumnTitleSignal = signal('', ...(ngDevMode ? [{ debugName: "sortedColumnTitleSignal" }] : /* istanbul ignore next */ []));
-    sortedColumnDirectionSignal = signal('none', ...(ngDevMode ? [{ debugName: "sortedColumnDirectionSignal" }] : /* istanbul ignore next */ []));
-    abstractSortState = new EventEmitter();
-    /**
-     * Creates an initial sort state for a table based on the provided table data.
-     *
-     * @param tableData - Array of table data objects representing table rows.
-     * @returns Initial sort state object with column names as keys and 'none' as values.
-     */
-    createSortState(tableData) {
-        return tableData?.length
-            ? Object.keys(tableData[0]).reduce((state, key) => {
-                state[key] = 'none';
-                return state;
-            }, {})
-            : {};
-    }
-    /**
-     * Initializes the sort state for the sortable table component.
-     *
-     * This method sets the initial sort state based on the existing sort state or creates a new one
-     * if none exists. It then updates the sort state signal with the initial sort state.
-     *
-     * If an existing sort state is found, it iterates over each entry and triggers the sort change
-     * for each key that has a sort type other than 'none'.
-     *
-     * @private
-     * @returns {void}
-     */
-    initialiseSortState() {
-        const existingSortState = this.abstractExistingSortState;
-        const initialSortState = existingSortState || this.createSortState(this.displayTableDataSignal());
-        this.applyFilterState();
-        this.sortStateSignal.set(initialSortState);
-        if (existingSortState) {
-            for (const [key, sortType] of Object.entries(existingSortState)) {
-                if (sortType !== 'none') {
-                    this.onSortChange({ key, sortType });
-                }
-            }
-        }
-        this.getSortedColumn();
-    }
-    /**
-     * Updates the sort state for a given column key and sort type.
-     * Resets the sort state for all other columns to 'none'.
-     *
-     * @param key - The column to sort by.
-     * @param sortType - Sorting order ('ascending' or 'descending').
-     */
-    updateSortState(key, sortType) {
-        this.sortStateSignal.set(Object.keys(this.sortStateSignal()).reduce((state, columnKey) => {
-            state[columnKey] = columnKey === key ? sortType : 'none';
-            return state;
-        }, {}));
-    }
-    /**
-     * Retrieves the sorted table data based on the specified key and sort type.
-     *
-     * @param key - The key of the property to sort by.
-     * @param sortType - The type of sorting to apply, either 'ascending' or 'descending'.
-     * @returns An array of sorted table data objects.
-     */
-    getSortedTableData(key, sortType) {
-        return sortType === 'ascending'
-            ? this.sortService.sortObjectArrayAsc(this.filteredTableDataSignal(), key)
-            : this.sortService.sortObjectArrayDesc(this.filteredTableDataSignal(), key);
-    }
-    /**
-     * Determines the first column with a sort state other than 'none' and updates the sorted column signals accordingly.
-     *
-     * - If a sorted column is found, updates the `sortedColumnTitleSignal` and `sortedColumnDirectionSignal` with the column key and state.
-     * - If no sorted column is found, sets the `sortedColumnTitleSignal` to an empty string and `sortedColumnDirectionSignal` to 'none'.
-     *
-     * @private
-     * @returns {void}
-     */
-    getSortedColumn() {
-        // Find the first column that has a sort state other than 'none'
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const sortedColumn = Object.entries(this.sortStateSignal()).find(([_, state]) => state !== 'none');
-        // If a sorted column is found, set the signal to the sorted column key and state
-        if (sortedColumn) {
-            const [columnKey, state] = sortedColumn;
-            this.sortedColumnTitleSignal.set(columnKey);
-            this.sortedColumnDirectionSignal.set(state);
-        }
-        else {
-            // Otherwise, set the signal to null
-            this.sortedColumnTitleSignal.set('');
-            this.sortedColumnDirectionSignal.set('none');
-        }
-    }
-    /**
-     * Handles the change in sorting for the table.
-     *
-     * @param event - An object containing the key to sort by and the sort type.
-     * @param event.key - The key of the column to sort.
-     * @param event.sortType - The type of sorting to apply ('ascending' or 'descending').
-     *
-     * This method updates the sort state, sorts the table data based on the provided key and sort type,
-     * updates the table data signal, and emits the updated sort state.
-     */
-    onSortChange(event) {
-        const { key, sortType } = event;
-        this.updateSortState(key, sortType);
-        this.getSortedColumn();
-        const sortedData = this.getSortedTableData(key, sortType);
-        // Update the table data signal
-        this.sortedTableDataSignal.set(sortedData);
-        // Emit the updated sort state
-        this.abstractSortState.emit(this.sortStateSignal());
-    }
-    /**
-     * Lifecycle hook to initialise the sort state.
-     */
-    ngOnInit() {
-        this.initialiseSortState();
-    }
-    /**
-     * Applies the current filters to the table data and updates the sorted data accordingly.
-     *
-     * This method overrides the parent implementation to additionally handle sorting.
-     * If there is an active sort key, it applies the corresponding sort to the filtered data.
-     * If no sort key is active, it simply updates the sorted data to match the filtered data.
-     *
-     * @override
-     */
-    onApplyFilters() {
-        super.onApplyFilters();
-        const key = this.sortedColumnTitleSignal();
-        const sortType = this.sortedColumnDirectionSignal();
-        if (!key || sortType === 'none') {
-            this.sortedTableDataSignal.set([...this.filteredTableDataSignal()]);
-        }
-        else {
-            this.onSortChange({ key, sortType });
-        }
-    }
-    /**
-     * Clears all filters applied to the table and restores the data to its unfiltered state.
-     * If a sort is currently active, re-applies the sort after clearing filters.
-     * Otherwise, resets the sorted table data to match the filtered data.
-     *
-     * @override
-     */
-    clearAllFilters() {
-        super.clearAllFilters();
-        const key = this.sortedColumnTitleSignal();
-        const sortType = this.sortedColumnDirectionSignal();
-        if (!key || sortType === 'none') {
-            this.sortedTableDataSignal.set([...this.filteredTableDataSignal()]);
-        }
-        else {
-            this.onSortChange({ key, sortType });
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.21", ngImport: i0, type: AbstractSortableTableComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.21", type: AbstractSortableTableComponent, isStandalone: true, selector: "ng-component", outputs: { abstractSortState: "abstractSortState" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.21", ngImport: i0, type: AbstractSortableTableComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: '',
-                }]
-        }], propDecorators: { abstractSortState: [{
-                type: Output
-            }] } });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+import * as i0 from "@angular/core";
+import { Component, EventEmitter, Output, effect, inject, signal } from "@angular/core";
+import { SortService } from "@hmcts/opal-frontend-common/services/sort-service";
+import { AbstractTableFilterComponent } from "@hmcts/opal-frontend-common/components/abstract/abstract-table-filter";
+var AbstractSortableTableComponent = class AbstractSortableTableComponent extends AbstractTableFilterComponent {
+	sortService = inject(SortService);
+	syncSortedDataEffect = effect(() => {
+		const filtered = this.filteredTableDataSignal();
+		const currentSort = this.sortStateSignal();
+		if (!Object.keys(currentSort).some((k) => currentSort[k] !== "none")) this.sortedTableDataSignal.set([...filtered]);
+	}, ...ngDevMode ? [{ debugName: "syncSortedDataEffect" }] : /* istanbul ignore next */ []);
+	displayTableDataSignal = signal([], ...ngDevMode ? [{ debugName: "displayTableDataSignal" }] : /* istanbul ignore next */ []);
+	filteredTableDataSignal = signal([], ...ngDevMode ? [{ debugName: "filteredTableDataSignal" }] : /* istanbul ignore next */ []);
+	sortedTableDataSignal = signal([], ...ngDevMode ? [{ debugName: "sortedTableDataSignal" }] : /* istanbul ignore next */ []);
+	abstractExistingSortState = null;
+	sortStateSignal = signal({}, ...ngDevMode ? [{ debugName: "sortStateSignal" }] : /* istanbul ignore next */ []);
+	sortedColumnTitleSignal = signal("", ...ngDevMode ? [{ debugName: "sortedColumnTitleSignal" }] : /* istanbul ignore next */ []);
+	sortedColumnDirectionSignal = signal("none", ...ngDevMode ? [{ debugName: "sortedColumnDirectionSignal" }] : /* istanbul ignore next */ []);
+	abstractSortState = new EventEmitter();
+	createSortState(tableData) {
+		return tableData?.length ? Object.keys(tableData[0]).reduce((state, key) => {
+			state[key] = "none";
+			return state;
+		}, {}) : {};
+	}
+	initialiseSortState() {
+		const existingSortState = this.abstractExistingSortState;
+		const initialSortState = existingSortState || this.createSortState(this.displayTableDataSignal());
+		this.applyFilterState();
+		this.sortStateSignal.set(initialSortState);
+		if (existingSortState) {
+			for (const [key, sortType] of Object.entries(existingSortState)) if (sortType !== "none") this.onSortChange({
+				key,
+				sortType
+			});
+		}
+		this.getSortedColumn();
+	}
+	updateSortState(key, sortType) {
+		this.sortStateSignal.set(Object.keys(this.sortStateSignal()).reduce((state, columnKey) => {
+			state[columnKey] = columnKey === key ? sortType : "none";
+			return state;
+		}, {}));
+	}
+	getSortedTableData(key, sortType) {
+		return sortType === "ascending" ? this.sortService.sortObjectArrayAsc(this.filteredTableDataSignal(), key) : this.sortService.sortObjectArrayDesc(this.filteredTableDataSignal(), key);
+	}
+	getSortedColumn() {
+		const sortedColumn = Object.entries(this.sortStateSignal()).find(([_, state]) => state !== "none");
+		if (sortedColumn) {
+			const [columnKey, state] = sortedColumn;
+			this.sortedColumnTitleSignal.set(columnKey);
+			this.sortedColumnDirectionSignal.set(state);
+		} else {
+			this.sortedColumnTitleSignal.set("");
+			this.sortedColumnDirectionSignal.set("none");
+		}
+	}
+	onSortChange(event) {
+		const { key, sortType } = event;
+		this.updateSortState(key, sortType);
+		this.getSortedColumn();
+		const sortedData = this.getSortedTableData(key, sortType);
+		this.sortedTableDataSignal.set(sortedData);
+		this.abstractSortState.emit(this.sortStateSignal());
+	}
+	ngOnInit() {
+		this.initialiseSortState();
+	}
+	onApplyFilters() {
+		super.onApplyFilters();
+		const key = this.sortedColumnTitleSignal();
+		const sortType = this.sortedColumnDirectionSignal();
+		if (!key || sortType === "none") this.sortedTableDataSignal.set([...this.filteredTableDataSignal()]);
+		else this.onSortChange({
+			key,
+			sortType
+		});
+	}
+	clearAllFilters() {
+		super.clearAllFilters();
+		const key = this.sortedColumnTitleSignal();
+		const sortType = this.sortedColumnDirectionSignal();
+		if (!key || sortType === "none") this.sortedTableDataSignal.set([...this.filteredTableDataSignal()]);
+		else this.onSortChange({
+			key,
+			sortType
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "21.2.25",
+		ngImport: i0,
+		type: AbstractSortableTableComponent,
+		deps: null,
+		target: i0.ɵɵFactoryTarget.Component
+	});
+	static ɵcmp = i0.ɵɵngDeclareComponent({
+		minVersion: "14.0.0",
+		version: "21.2.25",
+		type: AbstractSortableTableComponent,
+		isStandalone: true,
+		selector: "ng-component",
+		outputs: { abstractSortState: "abstractSortState" },
+		usesInheritance: true,
+		ngImport: i0,
+		template: "",
+		isInline: true
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "21.2.25",
+	ngImport: i0,
+	type: AbstractSortableTableComponent,
+	decorators: [{
+		type: Component,
+		args: [{ template: "" }]
+	}],
+	propDecorators: { abstractSortState: [{ type: Output }] }
+});
 export { AbstractSortableTableComponent };
-//# sourceMappingURL=hmcts-opal-frontend-common-components-abstract-abstract-sortable-table.mjs.map
+
+//# sourceMappingURL=hmcts-opal-frontend-common-components-abstract-abstract-sortable-table.mjs.map