@hmcts/opal-frontend-common 0.0.108 → 0.0.110

package/types/hmcts-opal-frontend-common-components-abstract-abstract-sortable-table.d.ts

@@ -1,113 +1,112 @@
-import * as _angular_core from '@angular/core';
-import { OnInit, EventEmitter } from '@angular/core';
-import { IAbstractTableData, IAbstractSortState } from '@hmcts/opal-frontend-common/components/abstract/abstract-sortable-table/interfaces';
-import { SortableValuesType, SortDirectionType } from '@hmcts/opal-frontend-common/components/abstract/abstract-sortable-table/types';
-import { AbstractTableFilterComponent } from '@hmcts/opal-frontend-common/components/abstract/abstract-table-filter';
-
-declare abstract class AbstractSortableTableComponent extends AbstractTableFilterComponent implements OnInit {
-    private readonly 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
-     */
-    protected syncSortedDataEffect: _angular_core.EffectRef;
-    displayTableDataSignal: _angular_core.WritableSignal<IAbstractTableData<SortableValuesType>[]>;
-    filteredTableDataSignal: _angular_core.WritableSignal<IAbstractTableData<SortableValuesType>[]>;
-    sortedTableDataSignal: _angular_core.WritableSignal<IAbstractTableData<SortableValuesType>[]>;
-    abstractExistingSortState: IAbstractSortState | null;
-    sortStateSignal: _angular_core.WritableSignal<IAbstractSortState>;
-    sortedColumnTitleSignal: _angular_core.WritableSignal<string>;
-    sortedColumnDirectionSignal: _angular_core.WritableSignal<SortDirectionType>;
-    abstractSortState: EventEmitter<IAbstractSortState>;
-    /**
-     * 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.
-     */
-    private createSortState;
-    /**
-     * 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}
-     */
-    private initialiseSortState;
-    /**
-     * 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').
-     */
-    private updateSortState;
-    /**
-     * 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.
-     */
-    private getSortedTableData;
-    /**
-     * 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}
-     */
-    private getSortedColumn;
-    /**
-     * 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.
-     */
-    protected onSortChange(event: {
-        key: string;
-        sortType: 'ascending' | 'descending';
-    }): void;
-    /**
-     * Lifecycle hook to initialise the sort state.
-     */
-    ngOnInit(): void;
-    /**
-     * 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(): void;
-    /**
-     * 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(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AbstractSortableTableComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AbstractSortableTableComponent, "ng-component", never, {}, { "abstractSortState": "abstractSortState"; }, never, never, true, never>;
-}
-
-export { AbstractSortableTableComponent };
+import * as i0 from "@angular/core";
+import { EventEmitter, OnInit } from "@angular/core";
+import { IAbstractSortState, IAbstractTableData } from "@hmcts/opal-frontend-common/components/abstract/abstract-sortable-table/interfaces";
+import { SortDirectionType, SortableValuesType } from "@hmcts/opal-frontend-common/components/abstract/abstract-sortable-table/types";
+import { AbstractTableFilterComponent } from "@hmcts/opal-frontend-common/components/abstract/abstract-table-filter";
+export declare abstract class AbstractSortableTableComponent extends AbstractTableFilterComponent implements OnInit {
+  private readonly 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
+   */
+  protected syncSortedDataEffect: import("@angular/core").EffectRef;
+  displayTableDataSignal: import("@angular/core").WritableSignal<IAbstractTableData<SortableValuesType>[]>;
+  filteredTableDataSignal: import("@angular/core").WritableSignal<IAbstractTableData<SortableValuesType>[]>;
+  sortedTableDataSignal: import("@angular/core").WritableSignal<IAbstractTableData<SortableValuesType>[]>;
+  abstractExistingSortState: IAbstractSortState | null;
+  sortStateSignal: import("@angular/core").WritableSignal<IAbstractSortState>;
+  sortedColumnTitleSignal: import("@angular/core").WritableSignal<string>;
+  sortedColumnDirectionSignal: import("@angular/core").WritableSignal<SortDirectionType>;
+  abstractSortState: EventEmitter<IAbstractSortState>;
+  /**
+   * 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.
+   */
+  private createSortState;
+  /**
+   * 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}
+   */
+  private initialiseSortState;
+  /**
+   * 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').
+   */
+  private updateSortState;
+  /**
+   * 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.
+   */
+  private getSortedTableData;
+  /**
+   * 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}
+   */
+  private getSortedColumn;
+  /**
+   * 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.
+   */
+  protected onSortChange(event: {
+    key: string;
+    sortType: 'ascending' | 'descending';
+  }): void;
+  /**
+   * Lifecycle hook to initialise the sort state.
+   */
+  ngOnInit(): void;
+  /**
+   * 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(): void;
+  /**
+   * 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(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AbstractSortableTableComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AbstractSortableTableComponent, "ng-component", never, {}, {
+    "abstractSortState": "abstractSortState";
+  }, never, never, true, never>;
+}

package/types/hmcts-opal-frontend-common-components-abstract-abstract-tab-data.d.ts

@@ -1,86 +1,83 @@
-import { ActivatedRoute } from '@angular/router';
-import { Observable } from 'rxjs';
-
-declare abstract class AbstractTabData {
-    private readonly router;
-    readonly activatedRoute: ActivatedRoute;
-    activeTab: string;
-    /**
-     * Creates an observable stream that fetches and transforms data based on the current tab.
-     *
-     * It fetches data using the `fetchData` function with parameters obtained from `getParams`,
-     * transforms the result using the `transform` function, and shares the result among subscribers.
-     *
-     * @template T The type of data returned by the fetchData observable.
-     * @template U The type of the value emitted by the resulting observable.
-     * @param fragment$ - An observable emitting the current tab identifier.
-     * @param getParams - A function that returns parameters for data fetching based on the tab.
-     * @param fetchData - A function that fetches data as an observable, given the parameters.
-     * @param transform - A function to transform the fetched data before emission.
-     * @returns An observable emitting the transformed fetched data, depending on the current tab.
-     */
-    private createConditionalStream;
-    /**
-     * Returns an observable stream of the current URL fragment, starting with the initial fragment or a default tab.
-     *
-     * This method listens to changes in the route fragment and emits the fragment value as a string.
-     * It starts with the current fragment (or the provided default tab if none exists), filters out falsy values,
-     * ensures only distinct values are emitted, and completes when the provided `destroy$` observable emits.
-     *
-     * @param defaultTab - The default tab to use if no fragment is present in the route snapshot.
-     * @param destroy$ - An observable that signals when to complete the fragment stream.
-     * @returns An observable emitting the current fragment string, updating on changes, and completing on destroy.
-     */
-    protected getFragmentStream(defaultTab: string, destroy$: Observable<void>): Observable<string>;
-    /**
-     * Wraps a fragment stream and executes the provided callback on each tab change.
-     *
-     * @param fragment$ - The fragment observable stream.
-     * @param clearFn - A function to execute when the tab changes.
-     * @returns The fragment stream with a side-effect to run `clearFn` on each emission.
-     */
-    protected clearCacheOnTabChange(fragment$: Observable<string>, clearFn: () => void): Observable<string>;
-    /**
-     * Creates an observable data stream for a tab, transforming the fetched data as needed.
-     *
-     * @template T The type of the data fetched.
-     * @template R The type of the transformed data.
-     * @param fragment$ An observable emitting the current tab fragment.
-     * @param getParams A function that returns fetch parameters based on the tab.
-     * @param fetchData A function that fetches data given the parameters.
-     * @param transform A function to transform the fetched data.
-     * @returns An observable emitting the transformed data for the current tab.
-     */
-    createTabDataStream<T, R>(fragment$: Observable<string>, getParams: (tab?: string) => any, fetchData: (params: any) => Observable<T>, transform: (data: T) => R): Observable<R>;
-    /**
-     * Creates an observable stream that emits a formatted count string based on the current tab and fragment.
-     *
-     * @template T - The type of the data returned by the fetchCount observable.
-     * @param fragment$ - An observable emitting the current fragment or tab identifier.
-     * @param getParams - A function that returns the parameters required for fetching the count.
-     * @param fetchCount - A function that takes the parameters and returns an observable emitting the count data.
-     * @param extractCount - A function that extracts the numeric count from the fetched data.
-     * @param formatFn - (Optional) A function to format the count as a string. Defaults to a simple string conversion.
-     * @returns An observable that emits the formatted count string whenever the fragment or parameters change.
-     */
-    createCountStream<T>(fragment$: Observable<string>, getParams: (tab?: string) => any, fetchCount: (params: any) => Observable<T>, extractCount: (data: T) => number, formatFn?: (count: number) => string): Observable<string>;
-    /**
-     * Handles the tab switch by updating the active tab and triggering a router fragment update.
-     *
-     * @param fragment - The identifier of the tab to activate.
-     */
-    handleTabSwitch(fragment: string): void;
-    /**
-     * Formats a count value, capping it at a specified maximum.
-     *
-     * If the count exceeds the cap, returns a string in the format "{cap}+".
-     * Otherwise, returns the count as a string.
-     *
-     * @param count - The number to format.
-     * @param cap - The maximum value to display before capping.
-     * @returns A string representing the count, capped if necessary.
-     */
-    formatCountWithCap(count: number, cap: number): string;
-}
-
-export { AbstractTabData };
+import { ActivatedRoute } from "@angular/router";
+import { Observable } from "rxjs";
+export declare abstract class AbstractTabData {
+  private readonly router;
+  readonly activatedRoute: ActivatedRoute;
+  activeTab: string;
+  /**
+   * Creates an observable stream that fetches and transforms data based on the current tab.
+   *
+   * It fetches data using the `fetchData` function with parameters obtained from `getParams`,
+   * transforms the result using the `transform` function, and shares the result among subscribers.
+   *
+   * @template T The type of data returned by the fetchData observable.
+   * @template U The type of the value emitted by the resulting observable.
+   * @param fragment$ - An observable emitting the current tab identifier.
+   * @param getParams - A function that returns parameters for data fetching based on the tab.
+   * @param fetchData - A function that fetches data as an observable, given the parameters.
+   * @param transform - A function to transform the fetched data before emission.
+   * @returns An observable emitting the transformed fetched data, depending on the current tab.
+   */
+  private createConditionalStream;
+  /**
+   * Returns an observable stream of the current URL fragment, starting with the initial fragment or a default tab.
+   *
+   * This method listens to changes in the route fragment and emits the fragment value as a string.
+   * It starts with the current fragment (or the provided default tab if none exists), filters out falsy values,
+   * ensures only distinct values are emitted, and completes when the provided `destroy$` observable emits.
+   *
+   * @param defaultTab - The default tab to use if no fragment is present in the route snapshot.
+   * @param destroy$ - An observable that signals when to complete the fragment stream.
+   * @returns An observable emitting the current fragment string, updating on changes, and completing on destroy.
+   */
+  protected getFragmentStream(defaultTab: string, destroy$: Observable<void>): Observable<string>;
+  /**
+   * Wraps a fragment stream and executes the provided callback on each tab change.
+   *
+   * @param fragment$ - The fragment observable stream.
+   * @param clearFn - A function to execute when the tab changes.
+   * @returns The fragment stream with a side-effect to run `clearFn` on each emission.
+   */
+  protected clearCacheOnTabChange(fragment$: Observable<string>, clearFn: () => void): Observable<string>;
+  /**
+   * Creates an observable data stream for a tab, transforming the fetched data as needed.
+   *
+   * @template T The type of the data fetched.
+   * @template R The type of the transformed data.
+   * @param fragment$ An observable emitting the current tab fragment.
+   * @param getParams A function that returns fetch parameters based on the tab.
+   * @param fetchData A function that fetches data given the parameters.
+   * @param transform A function to transform the fetched data.
+   * @returns An observable emitting the transformed data for the current tab.
+   */
+  createTabDataStream<T, R>(fragment$: Observable<string>, getParams: (tab?: string) => any, fetchData: (params: any) => Observable<T>, transform: (data: T) => R): Observable<R>;
+  /**
+   * Creates an observable stream that emits a formatted count string based on the current tab and fragment.
+   *
+   * @template T - The type of the data returned by the fetchCount observable.
+   * @param fragment$ - An observable emitting the current fragment or tab identifier.
+   * @param getParams - A function that returns the parameters required for fetching the count.
+   * @param fetchCount - A function that takes the parameters and returns an observable emitting the count data.
+   * @param extractCount - A function that extracts the numeric count from the fetched data.
+   * @param formatFn - (Optional) A function to format the count as a string. Defaults to a simple string conversion.
+   * @returns An observable that emits the formatted count string whenever the fragment or parameters change.
+   */
+  createCountStream<T>(fragment$: Observable<string>, getParams: (tab?: string) => any, fetchCount: (params: any) => Observable<T>, extractCount: (data: T) => number, formatFn?: (count: number) => string): Observable<string>;
+  /**
+   * Handles the tab switch by updating the active tab and triggering a router fragment update.
+   *
+   * @param fragment - The identifier of the tab to activate.
+   */
+  handleTabSwitch(fragment: string): void;
+  /**
+   * Formats a count value, capping it at a specified maximum.
+   *
+   * If the count exceeds the cap, returns a string in the format "{cap}+".
+   * Otherwise, returns the count as a string.
+   *
+   * @param count - The number to format.
+   * @param cap - The maximum value to display before capping.
+   * @returns A string representing the count, capped if necessary.
+   */
+  formatCountWithCap(count: number, cap: number): string;
+}

package/types/hmcts-opal-frontend-common-components-abstract-abstract-table-filter-interfaces.d.ts

@@ -1,17 +1,14 @@
-import { SortableValuesType } from '@hmcts/opal-frontend-common/components/abstract/abstract-table-filter/types';
-
-interface IAbstractTableFilterOption {
-    label: string;
-    value: string | number;
-    count?: number;
-    selected: boolean;
+import { SortableValuesType } from "@hmcts/opal-frontend-common/components/abstract/abstract-table-filter/types";
+export interface IAbstractTableFilterOption {
+  label: string;
+  value: string | number;
+  count?: number;
+  selected: boolean;
 }
-interface IAbstractTableFilterCategory {
-    categoryName: string;
-    options: IAbstractTableFilterOption[];
+export interface IAbstractTableFilterCategory {
+  categoryName: string;
+  options: IAbstractTableFilterOption[];
 }
-interface IAbstractTableData<T extends SortableValuesType> {
-    [key: string]: T | T[];
-}
-
-export type { IAbstractTableData, IAbstractTableFilterCategory, IAbstractTableFilterOption };
+export interface IAbstractTableData<T extends SortableValuesType> {
+  [key: string]: T | T[];
+}

package/types/hmcts-opal-frontend-common-components-abstract-abstract-table-filter-types.d.ts

@@ -1,3 +1 @@
-type SortableValuesType = string | number | boolean | Date | null | undefined;
-
-export type { SortableValuesType };
+export type SortableValuesType = string | number | boolean | Date | null | undefined;