@decaf-ts/for-angular 0.0.10 → 0.0.11

package/dist/lib/esm2022/components/list/list.component.mjs

@@ -0,0 +1,1236 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, EventEmitter, Output, Input, HostListener } from '@angular/core';
+import { IonInfiniteScroll, IonInfiniteScrollContent, IonItem, IonLabel, IonList, IonRefresher, IonRefresherContent, IonSkeletonText, IonText, IonThumbnail, IonLoading } from '@ionic/angular/standalone';
+import { debounceTime, Subject } from 'rxjs';
+import { OperationKeys } from '@decaf-ts/db-decorators';
+import { Model, Primitives } from '@decaf-ts/decorator-validation';
+import { Condition, OrderDirection } from '@decaf-ts/core';
+import { Dynamic, EventConstants, ComponentsTagNames } from '../../engine';
+import { ForAngularModule } from '../../for-angular.module';
+import { NgxBaseComponent } from '../../engine/NgxBaseComponent';
+import { stringToBoolean, formatDate, isValidDate } from '../../helpers';
+import { SearchbarComponent } from '../searchbar/searchbar.component';
+import { EmptyStateComponent } from '../empty-state/empty-state.component';
+import { ListItemComponent } from '../list-item/list-item.component';
+import { ComponentRendererComponent } from '../component-renderer/component-renderer.component';
+import { PaginationComponent } from '../pagination/pagination.component';
+import { ListComponentsTypes } from './constants';
+import { FilterComponent } from '../filter/filter.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular/standalone";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+/**
+ * @description A versatile list component that supports various data display modes.
+ * @summary This component provides a flexible way to display lists of data with support
+ * for infinite scrolling, pagination, searching, and custom item rendering. It can fetch
+ * data from various sources including models, functions, or direct data input.
+ *
+ * The component supports two main display types:
+ * 1. Infinite scrolling - Loads more data as the user scrolls
+ * 2. Pagination - Displays data in pages with navigation controls
+ *
+ * Additional features include:
+ * - Pull-to-refresh functionality
+ * - Search filtering
+ * - Empty state customization
+ * - Custom item rendering
+ * - Event emission for interactions
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User
+ *   participant L as ListComponent
+ *   participant D as Data Source
+ *   participant E as External Components
+ *
+ *   U->>L: Initialize component
+ *   L->>L: ngOnInit()
+ *   L->>D: Request initial data
+ *   D-->>L: Return data
+ *   L->>L: Process and display data
+ *
+ *   alt User scrolls (Infinite mode)
+ *     U->>L: Scroll to bottom
+ *     L->>D: Request more data
+ *     D-->>L: Return additional data
+ *     L->>L: Append to existing data
+ *   else User changes page (Paginated mode)
+ *     U->>L: Click page number
+ *     L->>L: handlePaginate()
+ *     L->>D: Request data for page
+ *     D-->>L: Return page data
+ *     L->>L: Replace displayed data
+ *   end
+ *
+ *   alt User searches
+ *     U->>L: Enter search term
+ *     L->>L: handleSearch()
+ *     L->>D: Filter data by search term
+ *     D-->>L: Return filtered data
+ *     L->>L: Update displayed data
+ *   end
+ *
+ *   alt User clicks item
+ *     U->>L: Click list item
+ *     L->>L: handleClick()
+ *     L->>E: Emit clickEvent
+ *   end
+ *
+ * @example
+ * <ngx-decaf-list
+ *   [source]="dataSource"
+ *   [limit]="10"
+ *   [type]="'infinite'"
+ *   [showSearchbar]="true"
+ *   (clickEvent)="handleItemClick($event)"
+ *   (refreshEvent)="handleRefresh($event)">
+ * </ngx-decaf-list>
+ *
+ * @extends {NgxBaseComponent}
+ * @implements {OnInit}
+ */
+let ListComponent = class ListComponent extends NgxBaseComponent {
+    /**
+     * @description Initializes a new instance of the ListComponent.
+     * @summary Creates a new ListComponent and sets up the base component with the appropriate
+     * component name. This constructor is called when Angular instantiates the component and
+     * before any input properties are set. It passes the component name to the parent class
+     * constructor to enable proper localization and component identification.
+     *
+     * The constructor is intentionally minimal, with most initialization logic deferred to
+     * the ngOnInit lifecycle hook. This follows Angular best practices by keeping the constructor
+     * focused on dependency injection and basic setup, while complex initialization that depends
+     * on input properties is handled in ngOnInit.
+     *
+     * @memberOf ListComponent
+     */
+    constructor() {
+        super("ListComponent");
+        /**
+         * @description The display mode for the list component.
+         * @summary Determines how the list data is loaded and displayed. Options include:
+         * - INFINITE: Loads more data as the user scrolls (infinite scrolling)
+         * - PAGINATED: Displays data in pages with navigation controls
+         *
+         * @type {ListComponentsTypes}
+         * @default ListComponentsTypes.INFINITE
+         * @memberOf ListComponent
+         */
+        this.type = ListComponentsTypes.INFINITE;
+        /**
+         * @description Controls whether the component uses translation services.
+         * @summary When set to true, the component will attempt to use translation services
+         * for any text content. This allows for internationalization of the list component.
+         *
+         * @type {StringOrBoolean}
+         * @default true
+         * @memberOf ListComponent
+         */
+        this.translatable = true;
+        /**
+         * @description Controls the visibility of the search bar.
+         * @summary When set to true, displays a search bar at the top of the list that allows
+         * users to filter the list items. The search functionality works by filtering the
+         * existing data or by triggering a new data fetch with search parameters.
+         *
+         * @type {StringOrBoolean}
+         * @default true
+         * @memberOf ListComponent
+         */
+        this.showSearchbar = true;
+        /**
+         * @description Direct data input for the list component.
+         * @summary Provides a way to directly pass data to the list component instead of
+         * fetching it from a source. When both data and source are provided, the component
+         * will use the source to fetch data only if the data array is empty.
+         *
+         * @type {KeyValue[] | undefined}
+         * @default undefined
+         * @memberOf ListComponent
+         */
+        this.data = undefined;
+        /**
+         * @description The starting index for data fetching.
+         * @summary Specifies the index from which to start fetching data. This is used
+         * for pagination and infinite scrolling to determine which subset of data to load.
+         *
+         * @type {number}
+         * @default 0
+         * @memberOf ListComponent
+         */
+        this.start = 0;
+        /**
+         * @description The number of items to fetch per page or load operation.
+         * @summary Determines how many items are loaded at once during pagination or
+         * infinite scrolling. This affects the size of data chunks requested from the source.
+         *
+         * @type {number}
+         * @default 10
+         * @memberOf ListComponent
+         */
+        this.limit = 10;
+        /**
+         * @description Controls whether more data can be loaded.
+         * @summary When set to true, the component will allow loading additional data
+         * through infinite scrolling or pagination. When false, the component will not
+         * attempt to load more data beyond what is initially displayed.
+         *
+         * @type {StringOrBoolean}
+         * @default true
+         * @memberOf ListComponent
+         */
+        this.loadMoreData = true;
+        /**
+         * @description The style of dividing lines between list items.
+         * @summary Determines how dividing lines appear between list items. Options include:
+         * - "inset": Lines are inset from the edges
+         * - "full": Lines extend the full width
+         * - "none": No dividing lines
+         *
+         * @type {"inset" | "full" | "none"}
+         * @default "full"
+         * @memberOf ListComponent
+         */
+        this.lines = "full";
+        /**
+         * @description Controls whether the list has inset styling.
+         * @summary When set to true, the list will have inset styling with rounded corners
+         * and margin around the edges. This creates a card-like appearance for the list.
+         *
+         * @type {StringOrBoolean}
+         * @default false
+         * @memberOf ListComponent
+         */
+        this.inset = false;
+        /**
+         * @description The threshold for triggering infinite scroll loading.
+         * @summary Specifies how close to the bottom of the list the user must scroll
+         * before the component triggers loading of additional data. This is expressed
+         * as a percentage of the list height.
+         *
+         * @type {string}
+         * @default "15%"
+         * @memberOf ListComponent
+         */
+        this.scrollThreshold = "15%";
+        /**
+         * @description The position where new items are added during infinite scrolling.
+         * @summary Determines whether new items are added to the top or bottom of the list
+         * when loading more data through infinite scrolling.
+         *
+         * @type {"bottom" | "top"}
+         * @default "bottom"
+         * @memberOf ListComponent
+         */
+        this.scrollPosition = "bottom";
+        /**
+         * @description Controls the visibility of the pull-to-refresh feature.
+         * @summary When set to true, enables the pull-to-refresh functionality that allows
+         * users to refresh the list data by pulling down from the top of the list.
+         *
+         * @type {StringOrBoolean}
+         * @default true
+         * @memberOf ListComponent
+         */
+        this.showRefresher = true;
+        /**
+         * @description The type of spinner to display during loading operations.
+         * @summary Specifies the visual style of the loading spinner shown during data
+         * fetching operations. Uses Ionic's predefined spinner types.
+         *
+         * @type {SpinnerTypes}
+         * @default "circular"
+         * @memberOf ListComponent
+         */
+        this.loadingSpinner = "circular";
+        // /**
+        //  * @description Query parameters for data fetching.
+        //  * @summary Specifies additional query parameters to use when fetching data from
+        //  * the source. This can be provided as a string (JSON) or a direct object.
+        //  *
+        //  * @type {string | KeyValue | undefined}
+        //  * @memberOf ListComponent
+        //  */
+        // @Input()
+        // query?: string | KeyValue;
+        /**
+         * @description Controls whether the filtering functionality is enabled.
+         * @summary When set to true, enables the filter component that allows users to create
+         * complex search criteria with multiple field filters, conditions, and values.
+         * When false, disables the filter interface entirely.
+         *
+         * @type {StringOrBoolean}
+         * @default true
+         * @memberOf ListComponent
+         */
+        this.enableFilter = true;
+        /**
+         * @description Sorting parameters for data fetching.
+         * @summary Specifies how the fetched data should be sorted. This can be provided
+         * as a string (field name with optional direction) or a direct object.
+         *
+         * @type {string | KeyValue | undefined}
+         * @memberOf ListComponent
+         */
+        this.sortDirection = OrderDirection.DSC;
+        /**
+         * @description Controls whether sorting functionality is disabled.
+         * @summary When set to true, disables the sort controls and prevents users from
+         * changing the sort order or field. The list will maintain its default or
+         * programmatically set sort configuration without user interaction.
+         *
+         * @type {StringOrBoolean}
+         * @default false
+         * @memberOf ListComponent
+         */
+        this.disableSort = false;
+        /**
+         * @description Icon to display when the list is empty.
+         * @summary Specifies the icon shown in the empty state when no data is available.
+         * This can be any icon name supported by the application's icon system.
+         *
+         * @type {string | undefined}
+         * @default 'ti-database-exclamation'
+         * @memberOf ListComponent
+         */
+        this.emptyIcon = 'ti-database-exclamation';
+        /**
+         * @description Configuration for the empty state display.
+         * @summary Customizes how the empty state is displayed when no data is available.
+         * This includes the title, subtitle, button text, icon, and navigation link.
+         *
+         * @type {Partial<IListEmptyResult>}
+         * @default {
+         *   title: 'empty.title',
+         *   subtitle: 'empty.subtitle',
+         *   showButton: false,
+         *   icon: 'alert-circle-outline',
+         *   buttonText: 'locale.empty.button',
+         *   link: ''
+         * }
+         * @memberOf ListComponent
+         */
+        this.empty = {
+            title: 'empty.title',
+            subtitle: 'empty.subtitle',
+            showButton: false,
+            icon: 'alert-circle-outline',
+            buttonText: 'locale.empty.button',
+            link: ''
+        };
+        /**
+         * @description The current page number in paginated mode.
+         * @summary Tracks which page is currently being displayed when the component
+         * is in paginated mode. This is used for pagination controls and data fetching.
+         *
+         * @type {number}
+         * @default 1
+         * @memberOf ListComponent
+         */
+        this.page = 1;
+        /**
+         * @description Indicates whether a refresh operation is in progress.
+         * @summary When true, the component is currently fetching new data. This is used
+         * to control loading indicators and prevent duplicate refresh operations from
+         * being triggered simultaneously.
+         *
+         * @type {boolean}
+         * @default false
+         * @memberOf ListComponent
+         */
+        this.refreshing = false;
+        /**
+         * @description Array used for rendering skeleton loading placeholders.
+         * @summary Contains placeholder items that are displayed during data loading.
+         * The length of this array determines how many skeleton items are shown.
+         *
+         * @type {string[]}
+         * @default new Array(2)
+         * @memberOf ListComponent
+         */
+        this.skeletonData = new Array(2);
+        /**
+         * @description The last page number that was displayed.
+         * @summary Keeps track of the previously displayed page number, which is useful
+         * for handling navigation and search operations in paginated mode.
+         *
+         * @type {number}
+         * @default 1
+         * @memberOf ListComponent
+         */
+        this.lastPage = 1;
+        /**
+         * @description Event emitter for refresh operations.
+         * @summary Emits an event when the list data is refreshed, either through pull-to-refresh
+         * or programmatic refresh. The event includes the refreshed data and component information.
+         *
+         * @type {EventEmitter<BaseCustomEvent>}
+         * @memberOf ListComponent
+         */
+        this.refreshEvent = new EventEmitter();
+        /**
+         * @description Event emitter for item click interactions.
+         * @summary Emits an event when a list item is clicked. The event includes the data
+         * of the clicked item, allowing parent components to respond to the interaction.
+         *
+         * @type {EventEmitter<KeyValue>}
+         * @memberOf ListComponent
+         */
+        this.clickEvent = new EventEmitter();
+        /**
+         * @description Subject for debouncing click events.
+         * @summary Uses RxJS Subject to collect click events and emit them after a debounce
+         * period. This prevents multiple rapid clicks from triggering multiple events.
+         *
+         * @private
+         * @type {Subject<CustomEvent | ListItemCustomEvent | RendererCustomEvent>}
+         * @memberOf ListComponent
+         */
+        this.clickItemSubject = new Subject();
+        /**
+         * @description Subject for debouncing repository observation events.
+         * @summary RxJS Subject that collects repository change events and emits them after
+         * a debounce period. This prevents multiple rapid repository changes from triggering
+         * multiple list refresh operations, improving performance and user experience.
+         *
+         * @private
+         * @type {Subject<any>}
+         * @memberOf ListComponent
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.observerSubjet = new Subject();
+        /**
+         * @description Observer object for repository change notifications.
+         * @summary Implements the Observer interface to receive notifications when the
+         * underlying data repository changes. This enables automatic list updates when
+         * data is created, updated, or deleted through the repository.
+         *
+         * @private
+         * @type {Observer}
+         * @memberOf ListComponent
+         */
+        this.observer = { refresh: async (...args) => this.observeRepository(...args) };
+    }
+    /**
+     * @description Initializes the component after Angular sets the input properties.
+     * @summary Sets up the component by initializing event subscriptions, processing boolean
+     * inputs, and loading the initial data. This method prepares the component for user
+     * interaction by ensuring all properties are properly initialized and data is loaded.
+     *
+     * @returns {Promise<void>}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant L as ListComponent
+     *   participant D as Data Source
+     *
+     *   A->>L: ngOnInit()
+     *   L->>L: Set up click event debouncing
+     *   L->>L: Process boolean inputs
+     *   L->>L: Configure component based on inputs
+     *   L->>L: refresh()
+     *   L->>D: Request initial data
+     *   D-->>L: Return data
+     *   L->>L: Process and display data
+     *   L->>L: Configure empty state if needed
+     *   L->>L: initialize()
+     *
+     * @memberOf ListComponent
+     */
+    async ngOnInit() {
+        this.clickItemSubject.pipe(debounceTime(100)).subscribe(event => this.clickEventEmit(event));
+        this.observerSubjet.pipe(debounceTime(100)).subscribe(args => this.handleObserveEvent(args[0], args[1], args[2]));
+        this.enableFilter = stringToBoolean(this.enableFilter);
+        this.limit = Number(this.limit);
+        this.start = Number(this.start);
+        this.inset = stringToBoolean(this.inset);
+        this.showRefresher = stringToBoolean(this.showRefresher);
+        this.loadMoreData = stringToBoolean(this.loadMoreData);
+        this.showSearchbar = stringToBoolean(this.showSearchbar);
+        this.disableSort = stringToBoolean(this.disableSort);
+        if (typeof this.item?.['tag'] === 'boolean' && this.item?.['tag'] === true)
+            this.item['tag'] = ComponentsTagNames.LIST_ITEM;
+        await this.refresh();
+        if (this.operations.includes(OperationKeys.CREATE) && this.route)
+            this.empty.link = `${this.route}/${OperationKeys.CREATE}`;
+        this.initialize();
+        if (this.model instanceof Model && this._repository)
+            this._repository.observe(this.observer);
+    }
+    /**
+     * @description Cleans up resources when the component is destroyed.
+     * @summary Performs cleanup operations when the component is being removed from the DOM.
+     * This includes clearing references to models and data to prevent memory leaks.
+     *
+     * @returns {void}
+     * @memberOf ListComponent
+     */
+    ngOnDestroy() {
+        if (this._repository)
+            this._repository.unObserve(this.observer);
+        this.data = this.model = this._repository = this.paginator = undefined;
+    }
+    /**
+     * @description Handles repository observation events with debouncing.
+     * @summary Processes repository change notifications and routes them appropriately.
+     * For CREATE events with a UID, handles them immediately. For other events,
+     * passes them to the debounced observer subject to prevent excessive updates.
+     *
+     * @param {...unknown[]} args - The repository event arguments including table, event type, and UID
+     * @returns {Promise<void>}
+     * @memberOf ListComponent
+     */
+    async observeRepository(...args) {
+        const [table, event, uid] = args;
+        if (event === OperationKeys.CREATE && !!uid)
+            return this.handleObserveEvent(table, event, uid);
+        return this.observerSubjet.next(args);
+    }
+    /**
+     * @description Handles specific repository events and updates the list accordingly.
+     * @summary Processes repository change events (CREATE, UPDATE, DELETE) and performs
+     * the appropriate list operations. This includes adding new items, updating existing
+     * ones, or removing deleted items from the list display.
+     *
+     * @param {string} table - The table/model name that changed
+     * @param {OperationKeys} event - The type of operation (CREATE, UPDATE, DELETE)
+     * @param {string | number} uid - The unique identifier of the affected item
+     * @returns {Promise<void>}
+     * @memberOf ListComponent
+     */
+    async handleObserveEvent(table, event, uid) {
+        if (event === OperationKeys.CREATE) {
+            if (uid) {
+                await this.handleCreate(uid);
+            }
+            else {
+                await this.refresh(true);
+            }
+        }
+        else {
+            if (event === OperationKeys.UPDATE)
+                await this.handleUpdate(uid);
+            if (event === OperationKeys.DELETE)
+                this.handleDelete(uid);
+            this.refreshEventEmit();
+        }
+    }
+    /**
+     * @description Function for tracking items in the list.
+     * @summary Provides a tracking function for the `*ngFor` directive in the component template.
+     * This function is used to identify and control the rendering of items in the list,
+     * preventing duplicate or unnecessary rendering.
+     *
+     * The `trackItemFn` function takes two parameters: `index` (the index of the item in the list)
+     * and `item` (the actual item from the list). It returns the tracking key, which in this case
+     * is the union of the `uid` of the item with the model name.
+     *
+     * @param {number} index - The index of the item in the list.
+  
+     * @param {KeyValue | string | number} item - The actual item from the list.
+     * @returns {string | number} The tracking key for the item.
+     * @memberOf ListComponent
+     */
+    trackItemFn(index, item) {
+        return `${item?.['uid'] || item?.[this.pk]}-${index}`;
+    }
+    /**
+     * Handles the create event from the repository.
+     *
+     * @param {string | number} uid - The ID of the item to create.
+     * @returns {Promise<void>} A promise that resolves when the item is created and added to the list.
+     */
+    async handleCreate(uid) {
+        const result = await this._repository?.read(uid);
+        const item = this.mapResults([result])[0];
+        this.items = this.data = [item, ...this.items || []];
+    }
+    /**
+     * @description Handles the update event from the repository.
+     * @summary Updates the list item with the specified ID based on the new data.
+     *
+     * @param {string | number} uid - The ID of the item to update
+     * @returns {Promise<void>}
+     * @private
+     * @memberOf ListComponent
+     */
+    async handleUpdate(uid) {
+        const item = this.itemMapper(await this._repository?.read(uid) || {}, this.mapper);
+        this.data = [];
+        for (const key in this.items) {
+            const child = this.items[key];
+            if (child['uid'] === item['uid']) {
+                this.items[key] = Object.assign({}, child, item);
+                break;
+            }
+        }
+        setTimeout(() => {
+            this.data = [...this.items];
+        }, 0);
+    }
+    /**
+     * @description Removes an item from the list by ID.
+     * @summary Filters out an item with the specified ID from the data array and
+     * refreshes the list display. This is typically used after a delete operation.
+     *
+     * @param {string} uid - The ID of the item to delete
+     * @param {string} pk - The primary key field name
+     * @returns {Promise<void>}
+     *
+     * @memberOf ListComponent
+     */
+    handleDelete(uid, pk) {
+        if (!pk)
+            pk = this.pk;
+        this.items = this.data?.filter((item) => item['uid'] !== uid) || [];
+    }
+    /**
+     * @description Handles click events from list items.
+     * @summary Listens for global ListItemClickEvent events and passes them to the
+     * debounced click subject. This allows the component to respond to clicks on
+     * list items regardless of where they originate from.
+     *
+     * @param {ListItemCustomEvent | RendererCustomEvent} event - The click event
+     * @returns {void}
+     *
+     * @memberOf ListComponent
+     */
+    handleClick(event) {
+        this.clickItemSubject.next(event);
+    }
+    /**
+     * @description Handles search events from the search bar.
+     * @summary Processes search queries from the search bar component, updating the
+     * displayed data based on the search term. The behavior differs between infinite
+     * and paginated modes to provide the best user experience for each mode.
+     *
+     * @param {string | undefined} value - The search term or undefined to clear search
+     * @returns {Promise<void>}
+     *
+     * @mermaid
+     * flowchart TD
+     *   A[Search Event] --> B{Type is Infinite?}
+     *   B -->|Yes| C[Disable loadMoreData]
+     *   B -->|No| D[Enable loadMoreData]
+     *   C --> E{Search value undefined?}
+     *   E -->|Yes| F[Enable loadMoreData]
+     *   E -->|No| G[Store search value]
+     *   D --> G
+     *   F --> H[Reset page to 1]
+     *   G --> I[Refresh data]
+     *   H --> I
+     *
+     * @memberOf ListComponent
+     */
+    async handleSearch(value) {
+        if (this.type === ListComponentsTypes.INFINITE) {
+            this.loadMoreData = false;
+            if (value === undefined) {
+                this.loadMoreData = true;
+                this.page = 1;
+            }
+            this.searchValue = value;
+            await this.refresh(true);
+        }
+        else {
+            this.loadMoreData = true;
+            this.searchValue = value;
+            if (value === undefined)
+                this.page = this.lastPage;
+            await this.refresh(true);
+        }
+    }
+    /**
+     * @description Handles filter events from the filter component.
+     * @summary Processes filter queries from the filter component and applies them
+     * to the list data. This method acts as a bridge between the filter component
+     * and the search functionality, converting filter queries into search operations.
+     *
+     * @param {IFilterQuery | undefined} value - The filter query object or undefined to clear filters
+     * @returns {Promise<void>}
+     * @memberOf ListComponent
+     */
+    async handleFilter(value) {
+        await this.handleSearch(value);
+    }
+    /**
+     * @description Clears the current search and resets the list.
+     * @summary Convenience method that clears the search by calling handleSearch
+     * with undefined. This resets the list to show all data without filtering.
+     *
+     * @returns {Promise<void>}
+     * @memberOf ListComponent
+     */
+    async clearSearch() {
+        await this.handleSearch(undefined);
+    }
+    /**
+     * @description Emits a refresh event with the current data.
+     * @summary Creates and emits a refresh event containing the current list data.
+     * This notifies parent components that the list data has been refreshed.
+     *
+     * @param {KeyValue[]} [data] - Optional data to include in the event
+     * @returns {void}
+     *
+     * @memberOf ListComponent
+     */
+    refreshEventEmit(data) {
+        if (!data)
+            data = this.items;
+        this.skeletonData = new Array(data?.length || 2);
+        this.refreshEvent.emit({
+            name: EventConstants.REFRESH_EVENT,
+            data: data || [],
+            component: this.componentName
+        });
+    }
+    /**
+     * @description Emits a click event for a list item.
+     * @summary Processes and emits a click event when a list item is clicked.
+     * This extracts the relevant data from the event and passes it to parent components.
+     *
+     * @private
+     * @param {ListItemCustomEvent | RendererCustomEvent} event - The click event
+     * @returns {void}
+     *
+     * @memberOf ListComponent
+     */
+    clickEventEmit(event) {
+        this.clickEvent.emit(event);
+    }
+    /**
+     * @description Refreshes the list data from the configured source.
+     * @summary This method handles both initial data loading and subsequent refresh operations,
+     * including pull-to-refresh and infinite scrolling. It manages the data fetching process,
+     * updates the component's state, and handles pagination or infinite scrolling logic based
+     * on the component's configuration.
+     *
+     * The method performs the following steps:
+     * 1. Sets the refreshing flag to indicate a data fetch is in progress
+     * 2. Calculates the appropriate start and limit values based on pagination settings
+     * 3. Fetches data from the appropriate source (model or request)
+     * 4. Updates the component's data and emits a refresh event
+     * 5. Handles pagination or infinite scrolling state updates
+     * 6. Completes any provided event (like InfiniteScrollCustomEvent)
+     *
+     * @param {InfiniteScrollCustomEvent | RefresherCustomEvent | boolean} event - The event that triggered the refresh,
+     * or a boolean flag indicating if this is a forced refresh
+     * @returns {Promise<void>} A promise that resolves when the refresh operation is complete
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant L as ListComponent
+     *   participant D as Data Source
+     *   participant E as Event System
+     *
+     *   L->>L: refresh(event)
+     *   L->>L: Set refreshing flag
+     *   L->>L: Calculate start and limit
+     *   alt Using model
+     *     L->>D: getFromModel(force, start, limit)
+     *     D-->>L: Return data
+     *   else Using request
+     *     L->>D: getFromRequest(force, start, limit)
+     *     D-->>L: Return data
+     *   end
+     *   L->>E: refreshEventEmit()
+     *   alt Infinite scrolling mode
+     *     L->>L: Check if reached last page
+     *     alt Last page reached
+     *       L->>L: Complete scroll event
+     *       L->>L: Disable loadMoreData
+     *     else More pages available
+     *       L->>L: Increment page number
+     *       L->>L: Complete scroll event after delay
+     *     end
+     *   else Paginated mode
+     *     L->>L: Clear refreshing flag after delay
+     *   end
+     *
+     * @memberOf ListComponent
+     */
+    async refresh(event = false) {
+        //  if(typeof force !== 'boolean' && force.type === EventConstants.BACK_BUTTON_NAVIGATION) {
+        //    const {refresh} = (force as CustomEvent).detail;
+        //    if(!refresh)
+        //      return false;
+        //  }
+        this.refreshing = true;
+        const start = this.page > 1 ? (this.page - 1) * this.limit : this.start;
+        const limit = (this.page * (this.limit > 12 ? 12 : this.limit));
+        this.data = !this.model ?
+            await this.getFromRequest(!!event, start, limit)
+            : await this.getFromModel(!!event);
+        this.refreshEventEmit();
+        if (this.type === ListComponentsTypes.INFINITE) {
+            if (this.page === this.pages) {
+                if (event?.target)
+                    event.target.complete();
+                this.loadMoreData = false;
+            }
+            else {
+                this.page += 1;
+                this.refreshing = false;
+                setTimeout(() => {
+                    if (event?.target && event?.type !== EventConstants.BACK_BUTTON_NAVIGATION)
+                        event.target.complete();
+                }, 200);
+            }
+        }
+        else {
+            setTimeout(() => {
+                this.refreshing = false;
+            }, 200);
+        }
+    }
+    /**
+   * @description Handles pagination events from the pagination component.
+   * @summary Processes pagination events by updating the current page number and
+   * refreshing the list data to display the selected page. This method is called
+   * when a user interacts with the pagination controls to navigate between pages.
+   *
+   * @param {PaginationCustomEvent} event - The pagination event containing page information
+   * @returns {void}
+   *
+   * @memberOf ListComponent
+   */
+    handlePaginate(event) {
+        const { page } = event.data;
+        this.page = page;
+        this.refresh(true);
+    }
+    /**
+     * @description Handles pull-to-refresh events from the refresher component.
+     * @summary Processes refresh events triggered by the user pulling down on the list
+     * or by programmatic refresh requests. This method refreshes the list data and
+     * completes the refresher animation when the data is loaded.
+     *
+     * @param {InfiniteScrollCustomEvent | CustomEvent} [event] - The refresh event
+     * @returns {Promise<void>} A promise that resolves when the refresh operation is complete
+     *
+     * @memberOf ListComponent
+     */
+    async handleRefresh(event) {
+        await this.refresh(event || true);
+        if (event instanceof CustomEvent)
+            setTimeout(() => {
+                // Any calls to load data go here
+                event.target.complete();
+            }, 400);
+    }
+    /**
+     * @description Filters data based on a search string.
+     * @summary Processes the current data array to find items that match the provided
+     * search string. This uses the arrayQueryByString utility to perform the filtering
+     * across all properties of the items.
+     *
+     * @param {KeyValue[]} results - The array of items to search through
+     * @param {string} search - The search string to filter by
+     * @returns {KeyValue[]} A promise that resolves to the filtered array of items
+     *
+     * @memberOf ListComponent
+     */
+    parseSearchResults(results, search) {
+        return results.filter((item) => Object.values(item).some(value => value.toString().toLowerCase().includes(search?.toLowerCase())));
+    }
+    /**
+     * @description Fetches data from a request source.
+     * @summary Retrieves data from the configured source function or URL, processes it,
+     * and updates the component's data state. This method handles both initial data loading
+     * and subsequent refresh operations when using an external data source rather than a model.
+     *
+     * @param {boolean} force - Whether to force a refresh even if data already exists
+     * @param {number} start - The starting index for pagination
+     * @param {number} limit - The maximum number of items to retrieve
+     * @returns {Promise<KeyValue[]>} A promise that resolves to the fetched data
+     *
+     * @memberOf ListComponent
+     */
+    async getFromRequest(force = false, start, limit) {
+        let request = [];
+        if (!this.data?.length || force || this.searchValue?.length || !!this.searchValue) {
+            // (self.data as ListItem[]) = [];
+            if (!this.searchValue?.length && !this.searchValue) {
+                if (!this.source && !this.data?.length) {
+                    this.logger.info('No data and source passed to infinite list');
+                    return [];
+                }
+                if (this.source instanceof Function)
+                    request = await this.source();
+                if (!Array.isArray(request))
+                    request = request?.['response']?.['data'] || request?.['results'] || [];
+                this.data = [...await this.parseResult(request)];
+                if (this.data?.length)
+                    this.items = this.type === ListComponentsTypes.INFINITE ?
+                        (this.items || []).concat([...this.data.slice(start, limit)]) : [...request.slice(start, limit)];
+            }
+            else {
+                this.data = this.parseSearchResults(this.data, this.searchValue);
+                this.items = this.data;
+            }
+        }
+        if (this.loadMoreData && this.type === ListComponentsTypes.PAGINATED)
+            this.getMoreData(this.data?.length || 0);
+        return this.data || [];
+    }
+    /**
+     * @description Fetches data from a model source.
+     * @summary Retrieves data from the configured model using its pagination or find methods,
+     * processes it, and updates the component's data state. This method handles both initial
+     * data loading and subsequent refresh operations when using a model as the data source.
+     *
+     * @param {boolean} force - Whether to force a refresh even if data already exists
+     * @param {number} start - The starting index for pagination
+     * @param {number} limit - The maximum number of items to retrieve
+     * @returns {Promise<KeyValue[]>} A promise that resolves to the fetched data
+     *
+     * @memberOf ListComponent
+     */
+    async getFromModel(force = false) {
+        let data = [...this.data || []];
+        let request = [];
+        // getting model repository
+        if (!this._repository)
+            this._repository = this.repository;
+        const repo = this._repository;
+        if (!this.data?.length || force || this.searchValue?.length || !!this.searchValue) {
+            try {
+                if (!this.searchValue?.length && !this.searchValue) {
+                    this.data = [];
+                    // const rawQuery = this.parseQuery(self.model as Repository<Model>, start, limit);
+                    // request = this.parseResult(await (this.model as any)?.paginate(start, limit));
+                    if (!this.paginator) {
+                        this.paginator = await repo
+                            .select()
+                            .orderBy([this.pk, this.sortDirection])
+                            .paginate(this.limit);
+                    }
+                    request = await this.parseResult(this.paginator);
+                }
+                else {
+                    if (!this.indexes)
+                        this.indexes = (Object.values(this.mapper) || [this.pk]);
+                    const condition = this.parseConditions(this.searchValue);
+                    request = await this.parseResult(await repo.query(condition, (this.sortBy || this.pk), this.sortDirection));
+                    data = [];
+                }
+                data = this.type === ListComponentsTypes.INFINITE ? [...(data).concat(request)] : [...request];
+            }
+            catch (error) {
+                this.logger.error(error?.message || `Unable to find ${this.model} on registry. Return empty array from component`);
+            }
+        }
+        if (data?.length) {
+            if (this.searchValue) {
+                this.items = [...data];
+                if (this.items?.length <= this.limit)
+                    this.loadMoreData = false;
+            }
+            else {
+                this.items = [...data];
+            }
+        }
+        if (this.type === ListComponentsTypes.PAGINATED && this.paginator)
+            this.getMoreData(this.paginator.total);
+        return data || [];
+    }
+    /**
+     * @description Converts search values or filter queries into database conditions.
+     * @summary Transforms search input or complex filter queries into Condition objects
+     * that can be used for database querying. Handles both simple string/number searches
+     * across indexed fields and complex filter queries with multiple criteria.
+     *
+     * For simple searches (string/number):
+     * - Creates conditions that search across all indexed fields
+     * - Uses equality for numeric values and regex for string values
+     * - Combines conditions with OR logic to search multiple fields
+     *
+     * For complex filter queries:
+     * - Processes each filter item with its specific condition type
+     * - Supports Equal, Not Equal, Contains, Not Contains, Greater Than, Less Than
+     * - Updates sort configuration based on the filter query
+     * - Combines multiple filter conditions with OR logic
+     *
+     * @param {string | number | IFilterQuery} value - The search value or filter query object
+     * @returns {Condition<Model>} A Condition object for database querying
+     * @memberOf ListComponent
+     */
+    parseConditions(value) {
+        let _condition;
+        if (typeof value === Primitives.STRING || typeof value === Primitives.NUMBER) {
+            _condition = Condition.attribute(this.pk).eq(!isNaN(value) ? Number(value) : value);
+            for (const index of this.indexes) {
+                if (index === this.pk)
+                    continue;
+                let orCondition;
+                if (!isNaN(value)) {
+                    orCondition = Condition.attribute(index).eq(Number(value));
+                }
+                else {
+                    orCondition = Condition.attribute(index).regexp(value);
+                }
+                _condition = _condition.or(orCondition);
+            }
+        }
+        else {
+            const { query, sort } = value;
+            _condition = Condition.attribute(this.pk).dif('null');
+            if (query?.length)
+                _condition = undefined;
+            (query || []).forEach((item) => {
+                const { value, condition, index } = item;
+                let val = value;
+                if (index === this.pk || !isNaN(val))
+                    val = Number(val);
+                let orCondition;
+                switch (condition) {
+                    case "Equal":
+                        orCondition = Condition.attribute(index).eq(val);
+                        break;
+                    case "Not Equal":
+                        orCondition = Condition.attribute(index).dif(val);
+                        break;
+                    case "Not Contains":
+                        orCondition = !Condition.attribute(index).regexp(new RegExp(`^(?!.*${val}).*$`));
+                        break;
+                    case "Contains":
+                        orCondition = Condition.attribute(index).regexp(val);
+                        break;
+                    case "Greater Than":
+                        orCondition = Condition.attribute(index).gte(val);
+                        break;
+                    case "Less Than":
+                        orCondition = Condition.attribute(index).lte(val);
+                        break;
+                }
+                _condition = (!_condition ?
+                    orCondition : _condition.and(orCondition));
+            });
+            this.sortBy = sort?.value || this.pk;
+            this.sortDirection = sort?.direction || this.sortDirection;
+        }
+        console.log(_condition);
+        return _condition;
+    }
+    /**
+     * @description Processes query results into a standardized format.
+     * @summary Handles different result formats from various data sources, extracting
+     * pagination information when available and applying any configured data mapping.
+     * This ensures consistent data structure regardless of the source.
+     *
+     * @protected
+     * @param {KeyValue[] | Paginator} result - The raw query result
+     * @returns {KeyValue[]} The processed array of items
+     *
+     * @memberOf ListComponent
+     */
+    async parseResult(result) {
+        if (!Array.isArray(result) && ('page' in result && 'total' in result)) {
+            const paginator = result;
+            result = await paginator.page(this.page);
+            // TODO: Chage for result.total;
+            this.getMoreData(paginator.total);
+        }
+        else {
+            this.getMoreData(result?.length || 0);
+        }
+        return (Object.keys(this.mapper || {}).length) ?
+            this.mapResults(result) : result;
+    }
+    /**
+     * @description Updates pagination state based on data length.
+     * @summary Calculates whether more data is available and how many pages exist
+     * based on the total number of items and the configured limit per page.
+     * This information is used to control pagination UI and infinite scrolling behavior.
+     *
+     * @param {number} length - The total number of items available
+     * @returns {void}
+     *
+     * @memberOf ListComponent
+     */
+    getMoreData(length) {
+        if (this.type === ListComponentsTypes.INFINITE) {
+            if (this.paginator)
+                length = length * this.limit;
+            if (length <= this.limit) {
+                this.loadMoreData = false;
+            }
+            else {
+                this.pages = Math.floor(length / this.limit);
+                if ((this.pages * this.limit) < length)
+                    this.pages += 1;
+                if (this.pages === 1)
+                    this.loadMoreData = false;
+            }
+        }
+        else {
+            this.pages = length;
+            if (this.pages === 1)
+                this.loadMoreData = false;
+        }
+    }
+    /**
+     * @description Maps a single item using the configured mapper.
+     * @summary Transforms a data item according to the mapping configuration,
+     * extracting nested properties and formatting values as needed. This allows
+     * the component to display data in a format different from how it's stored.
+     *
+     * @protected
+     * @param {KeyValue} item - The item to map
+     * @param {KeyValue} mapper - The mapping configuration
+     * @param {KeyValue} [props] - Additional properties to include
+     * @returns {KeyValue} The mapped item
+     *
+     * @memberOf ListComponent
+     */
+    itemMapper(item, mapper, props) {
+        return Object.entries(mapper).reduce((accum, [key, value]) => {
+            const arrayValue = value.split('.');
+            if (!value) {
+                accum[key] = value;
+            }
+            else {
+                if (arrayValue.length === 1) {
+                    value = item?.[value] || value;
+                    if (isValidDate(value))
+                        value = `${formatDate(value)}`;
+                    accum[key] = value;
+                }
+                else {
+                    let val;
+                    for (const _value of arrayValue)
+                        val = !val
+                            ? item[_value]
+                            : (typeof val === 'string' ? JSON.parse(val) : val)[_value];
+                    if (isValidDate(new Date(val)))
+                        val = `${formatDate(val)}`;
+                    accum[key] = val === null || val === undefined ? value : val;
+                }
+            }
+            return Object.assign({}, props || {}, accum);
+        }, {});
+    }
+    /**
+     * @description Maps all result items using the configured mapper.
+     * @summary Applies the itemMapper to each item in the result set, adding
+     * common properties like operations and route information. This transforms
+     * the raw data into the format expected by the list item components.
+     *
+     * @param {KeyValue[]} data - The array of items to map
+     * @returns {KeyValue[]} The array of mapped items
+     *
+     * @memberOf ListComponent
+     */
+    mapResults(data) {
+        if (!data || !data.length)
+            return [];
+        // passing uid as prop to mapper
+        this.mapper = { ...this.mapper, ...{ uid: this.pk } };
+        const props = Object.assign({
+            operations: this.operations,
+            route: this.route,
+            ...Object.keys(this.item).reduce((acc, key) => {
+                acc[key] = this.item[key];
+                return acc;
+            }, {}),
+            // ... (!this.item.render ? {} :  Object.keys(this.item).reduce((acc: KeyValue, key: string) => {
+            //   acc[key] = this.item[key as keyof IListItemProp];
+            //   return acc;
+            // }, {}))
+        });
+        return data.reduce((accum, curr) => {
+            accum.push({ ...this.itemMapper(curr, this.mapper, props), ...{ pk: this.pk } });
+            return accum;
+        }, []);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ListComponent, isStandalone: true, selector: "ngx-decaf-list", inputs: { type: "type", translatable: "translatable", showSearchbar: "showSearchbar", data: "data", source: "source", start: "start", limit: "limit", loadMoreData: "loadMoreData", lines: "lines", inset: "inset", scrollThreshold: "scrollThreshold", scrollPosition: "scrollPosition", loadingText: "loadingText", showRefresher: "showRefresher", loadingSpinner: "loadingSpinner", enableFilter: "enableFilter", sortDirection: "sortDirection", sortBy: "sortBy", disableSort: "disableSort", emptyIcon: "emptyIcon", empty: "empty" }, outputs: { refreshEvent: "refreshEvent", clickEvent: "clickEvent" }, host: { listeners: { "window:ListItemClickEvent": "handleClick($event)", "window:searchbarEvent": "handleSearch($event)", "window:BackButtonNavigationEndEvent": "refresh($event)" } }, usesInheritance: true, ngImport: i0, template: "\n@if(showRefresher) {\n  <ion-refresher slot=\"fixed\" [pullFactor]=\"1\" [pullMin]=\"100\" [pullMax]=\"200\" (ionRefresh)=\"handleRefresh($event)\">\n    <ion-refresher-content />\n  </ion-refresher>\n}\n\n@if(showSearchbar) {\n  @if(model && enableFilter) {\n    <ngx-decaf-filter\n      [model]=\"model\"\n      [sortDirection]=\"sortDirection\"\n      [disableSort]=\"disableSort\"\n      (filterEvent)=\"handleFilter($event)\"\n      (searchEvent)=\"handleSearch($event)\"\n    />\n  } @else {\n    <ngx-decaf-searchbar [emitEventToWindow]=\"false\" [debounce]=\"500\" (searchEvent)=\"handleSearch($event)\" />\n  }\n}\n\n@if(data?.length) {\n  <ion-list [inset]=\"inset\" [lines]=\"lines\" #component>\n    @if(item?.tag) {\n      @for(child of items; track trackItemFn($index, child)) {\n        <ngx-decaf-component-renderer\n          [tag]=\"item.tag\"\n          (listenEvent)=\"handleEvent($event)\"\n          [globals]='{\n            item: child,\n            mapper: mapper,\n            route: route\n          }'>\n          </ngx-decaf-component-renderer>\n        }\n    } @else {\n      <ng-content></ng-content>\n    }\n  </ion-list>\n\n  @if(loadMoreData) {\n    @if(pages > 0 && type === 'paginated' && !searchValue?.length) {\n      <ngx-decaf-pagination\n        [totalPages]=\"pages\"\n        [current]=\"page\"\n        (clickEvent)=\"handlePaginate($event)\"\n      />\n\n    } @else {\n      <ion-infinite-scroll\n        [class]=\"searchValue?.length ? 'dcf-hidden' : ''\"\n        [position]=\"scrollPosition\"\n        [threshold]=\"scrollThreshold\"\n        (ionInfinite)=\"handleRefresh($event)\">\n        <ion-infinite-scroll-content [loadingSpinner]=\"loadingSpinner\" [loadingText]=\"loadingText\" />\n      </ion-infinite-scroll>\n    }\n  }\n} @else {\n  @if(refreshing) {\n    <ion-item *ngFor=\"let skl of skeletonData\">\n      <ion-thumbnail slot=\"start\">\n        <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n      </ion-thumbnail>\n      <ion-label>\n        <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n        <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n      </ion-label>\n    </ion-item>\n  } @else {\n    @if(!searchValue?.length) {\n      <ngx-decaf-empty-state\n        [title]=\"(locale + '.'+ empty.title) | translate\"\n        [subtitle]=\"(locale + '.'+ empty.subtitle) | translate\"\n        [buttonText]=\"empty.showButton ? (locale + '.'+ empty.button | translate) : ''\"\n        [buttonLink]=\"empty.showButton ? empty.route : ''\"\n      />\n    } @else {\n      <ngx-decaf-empty-state\n        icon=\"search-outline\"\n        ngClass=\"empty-search\"\n        [translatable]=\"true\"\n        title=\"search.title\"\n        subtitle=\"search.subtitle\"\n        [searchValue]=\"searchValue\"\n      />\n    }\n  }\n}\n\n", styles: ["ion-infinite-scroll-content ion-spinner{--color: var(--ion-color-primary)}@media (max-width: 768px){#end,[slot=end]{display:none!important}}\n"], dependencies: [{ kind: "ngmodule", type: ForAngularModule }, { kind: "component", type: i1.IonText, selector: "ion-text", inputs: ["color", "mode"] }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }, { kind: "component", type: IonRefresher, selector: "ion-refresher", inputs: ["closeDuration", "disabled", "mode", "pullFactor", "pullMax", "pullMin", "snapbackDuration"] }, { kind: "component", type: PaginationComponent, selector: "ngx-decaf-pagination", inputs: ["totalPages", "current"], outputs: ["clickEvent"] }, { kind: "component", type: IonList, selector: "ion-list", inputs: ["inset", "lines", "mode"] }, { kind: "component", type: IonItem, selector: "ion-item", inputs: ["button", "color", "detail", "detailIcon", "disabled", "download", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "target", "type"] }, { kind: "component", type: IonThumbnail, selector: "ion-thumbnail" }, { kind: "component", type: IonSkeletonText, selector: "ion-skeleton-text", inputs: ["animated"] }, { kind: "component", type: IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: IonRefresherContent, selector: "ion-refresher-content", inputs: ["pullingIcon", "pullingText", "refreshingSpinner", "refreshingText"] }, { kind: "component", type: IonInfiniteScroll, selector: "ion-infinite-scroll", inputs: ["disabled", "position", "threshold"] }, { kind: "component", type: IonInfiniteScrollContent, selector: "ion-infinite-scroll-content", inputs: ["loadingSpinner", "loadingText"] }, { kind: "component", type: SearchbarComponent, selector: "ngx-decaf-searchbar", inputs: ["autocomplete", "autocorrect", "animated", "buttonCancelText", "clearIcon", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "placeholder", "searchIcon", "showCancelButton", "showClearButton", "spellcheck", "type", "value", "queryKeys", "isVisible", "wrapper", "wrapperColor", "emitEventToWindow"], outputs: ["searchEvent"] }, { kind: "component", type: EmptyStateComponent, selector: "ngx-decaf-empty-state", inputs: ["title", "titleColor", "subtitle", "subtitleColor", "showIcon", "icon", "iconSize", "iconColor", "buttonLink", "buttonText", "buttonFill", "buttonColor", "buttonSize", "searchValue"] }, { kind: "component", type: FilterComponent, selector: "ngx-decaf-filter", inputs: ["indexes", "conditions", "sortBy", "disableSort"], outputs: ["filterEvent", "searchEvent"] }, { kind: "component", type: ComponentRendererComponent, selector: "ngx-decaf-component-renderer", inputs: ["tag", "globals", "model", "parent"], outputs: ["listenEvent"] }] }); }
+};
+ListComponent = __decorate([
+    Dynamic(),
+    __metadata("design:paramtypes", [])
+], ListComponent);
+export { ListComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-decaf-list', standalone: true, imports: [
+                        ForAngularModule,
+                        IonRefresher,
+                        IonLoading,
+                        PaginationComponent,
+                        IonList,
+                        IonItem,
+                        IonThumbnail,
+                        IonSkeletonText,
+                        IonLabel,
+                        IonText,
+                        IonRefresherContent,
+                        IonInfiniteScroll,
+                        IonInfiniteScrollContent,
+                        IonThumbnail,
+                        IonSkeletonText,
+                        SearchbarComponent,
+                        EmptyStateComponent,
+                        ListItemComponent,
+                        FilterComponent,
+                        ComponentRendererComponent
+                    ], template: "\n@if(showRefresher) {\n  <ion-refresher slot=\"fixed\" [pullFactor]=\"1\" [pullMin]=\"100\" [pullMax]=\"200\" (ionRefresh)=\"handleRefresh($event)\">\n    <ion-refresher-content />\n  </ion-refresher>\n}\n\n@if(showSearchbar) {\n  @if(model && enableFilter) {\n    <ngx-decaf-filter\n      [model]=\"model\"\n      [sortDirection]=\"sortDirection\"\n      [disableSort]=\"disableSort\"\n      (filterEvent)=\"handleFilter($event)\"\n      (searchEvent)=\"handleSearch($event)\"\n    />\n  } @else {\n    <ngx-decaf-searchbar [emitEventToWindow]=\"false\" [debounce]=\"500\" (searchEvent)=\"handleSearch($event)\" />\n  }\n}\n\n@if(data?.length) {\n  <ion-list [inset]=\"inset\" [lines]=\"lines\" #component>\n    @if(item?.tag) {\n      @for(child of items; track trackItemFn($index, child)) {\n        <ngx-decaf-component-renderer\n          [tag]=\"item.tag\"\n          (listenEvent)=\"handleEvent($event)\"\n          [globals]='{\n            item: child,\n            mapper: mapper,\n            route: route\n          }'>\n          </ngx-decaf-component-renderer>\n        }\n    } @else {\n      <ng-content></ng-content>\n    }\n  </ion-list>\n\n  @if(loadMoreData) {\n    @if(pages > 0 && type === 'paginated' && !searchValue?.length) {\n      <ngx-decaf-pagination\n        [totalPages]=\"pages\"\n        [current]=\"page\"\n        (clickEvent)=\"handlePaginate($event)\"\n      />\n\n    } @else {\n      <ion-infinite-scroll\n        [class]=\"searchValue?.length ? 'dcf-hidden' : ''\"\n        [position]=\"scrollPosition\"\n        [threshold]=\"scrollThreshold\"\n        (ionInfinite)=\"handleRefresh($event)\">\n        <ion-infinite-scroll-content [loadingSpinner]=\"loadingSpinner\" [loadingText]=\"loadingText\" />\n      </ion-infinite-scroll>\n    }\n  }\n} @else {\n  @if(refreshing) {\n    <ion-item *ngFor=\"let skl of skeletonData\">\n      <ion-thumbnail slot=\"start\">\n        <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n      </ion-thumbnail>\n      <ion-label>\n        <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n        <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n      </ion-label>\n    </ion-item>\n  } @else {\n    @if(!searchValue?.length) {\n      <ngx-decaf-empty-state\n        [title]=\"(locale + '.'+ empty.title) | translate\"\n        [subtitle]=\"(locale + '.'+ empty.subtitle) | translate\"\n        [buttonText]=\"empty.showButton ? (locale + '.'+ empty.button | translate) : ''\"\n        [buttonLink]=\"empty.showButton ? empty.route : ''\"\n      />\n    } @else {\n      <ngx-decaf-empty-state\n        icon=\"search-outline\"\n        ngClass=\"empty-search\"\n        [translatable]=\"true\"\n        title=\"search.title\"\n        subtitle=\"search.subtitle\"\n        [searchValue]=\"searchValue\"\n      />\n    }\n  }\n}\n\n", styles: ["ion-infinite-scroll-content ion-spinner{--color: var(--ion-color-primary)}@media (max-width: 768px){#end,[slot=end]{display:none!important}}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { type: [{
+                type: Input
+            }], translatable: [{
+                type: Input
+            }], showSearchbar: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], source: [{
+                type: Input
+            }], start: [{
+                type: Input
+            }], limit: [{
+                type: Input
+            }], loadMoreData: [{
+                type: Input
+            }], lines: [{
+                type: Input
+            }], inset: [{
+                type: Input
+            }], scrollThreshold: [{
+                type: Input
+            }], scrollPosition: [{
+                type: Input
+            }], loadingText: [{
+                type: Input
+            }], showRefresher: [{
+                type: Input
+            }], loadingSpinner: [{
+                type: Input
+            }], enableFilter: [{
+                type: Input
+            }], sortDirection: [{
+                type: Input
+            }], sortBy: [{
+                type: Input
+            }], disableSort: [{
+                type: Input
+            }], emptyIcon: [{
+                type: Input
+            }], empty: [{
+                type: Input
+            }], refreshEvent: [{
+                type: Output
+            }], clickEvent: [{
+                type: Output
+            }], handleClick: [{
+                type: HostListener,
+                args: ['window:ListItemClickEvent', ['$event']]
+            }], handleSearch: [{
+                type: HostListener,
+                args: ['window:searchbarEvent', ['$event']]
+            }], refresh: [{
+                type: HostListener,
+                args: ['window:BackButtonNavigationEndEvent', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/list/list.component.ts","../../../../../src/lib/components/list/list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, EventEmitter, Output, Input, HostListener, OnDestroy  } from '@angular/core';\nimport { InfiniteScrollCustomEvent, RefresherCustomEvent, SpinnerTypes } from '@ionic/angular';\nimport {\n  IonInfiniteScroll,\n  IonInfiniteScrollContent,\n  IonItem,\n  IonLabel,\n  IonList,\n  IonRefresher,\n  IonRefresherContent,\n  IonSkeletonText,\n  IonText,\n  IonThumbnail,\n  IonLoading\n} from '@ionic/angular/standalone';\nimport { debounceTime, Subject } from 'rxjs';\nimport { OperationKeys } from '@decaf-ts/db-decorators';\nimport { Model, Primitives } from '@decaf-ts/decorator-validation';\nimport { Condition, Observer, OrderDirection, Paginator } from '@decaf-ts/core';\nimport {\n  BaseCustomEvent,\n  Dynamic,\n  EventConstants,\n  ComponentsTagNames,\n  RendererCustomEvent,\n  StringOrBoolean,\n  KeyValue,\n  ListItemCustomEvent\n} from '../../engine';\nimport { ForAngularModule } from '../../for-angular.module';\nimport { NgxBaseComponent } from '../../engine/NgxBaseComponent';\nimport {\n  stringToBoolean,\n  formatDate,\n  isValidDate\n} from '../../helpers';\nimport { SearchbarComponent } from '../searchbar/searchbar.component';\nimport { EmptyStateComponent } from '../empty-state/empty-state.component';\nimport { ListItemComponent } from '../list-item/list-item.component';\nimport { ComponentRendererComponent } from '../component-renderer/component-renderer.component';\nimport { PaginationComponent } from '../pagination/pagination.component';\nimport { PaginationCustomEvent } from '../pagination/constants';\nimport { IListEmptyResult, ListComponentsTypes, DecafRepository } from './constants';\nimport { FunctionLike, IFilterQuery, IFilterQueryItem } from '../../engine/types';\nimport { FilterComponent } from '../filter/filter.component';\n\n/**\n * @description A versatile list component that supports various data display modes.\n * @summary This component provides a flexible way to display lists of data with support\n * for infinite scrolling, pagination, searching, and custom item rendering. It can fetch\n * data from various sources including models, functions, or direct data input.\n *\n * The component supports two main display types:\n * 1. Infinite scrolling - Loads more data as the user scrolls\n * 2. Pagination - Displays data in pages with navigation controls\n *\n * Additional features include:\n * - Pull-to-refresh functionality\n * - Search filtering\n * - Empty state customization\n * - Custom item rendering\n * - Event emission for interactions\n *\n * @mermaid\n * sequenceDiagram\n *   participant U as User\n *   participant L as ListComponent\n *   participant D as Data Source\n *   participant E as External Components\n *\n *   U->>L: Initialize component\n *   L->>L: ngOnInit()\n *   L->>D: Request initial data\n *   D-->>L: Return data\n *   L->>L: Process and display data\n *\n *   alt User scrolls (Infinite mode)\n *     U->>L: Scroll to bottom\n *     L->>D: Request more data\n *     D-->>L: Return additional data\n *     L->>L: Append to existing data\n *   else User changes page (Paginated mode)\n *     U->>L: Click page number\n *     L->>L: handlePaginate()\n *     L->>D: Request data for page\n *     D-->>L: Return page data\n *     L->>L: Replace displayed data\n *   end\n *\n *   alt User searches\n *     U->>L: Enter search term\n *     L->>L: handleSearch()\n *     L->>D: Filter data by search term\n *     D-->>L: Return filtered data\n *     L->>L: Update displayed data\n *   end\n *\n *   alt User clicks item\n *     U->>L: Click list item\n *     L->>L: handleClick()\n *     L->>E: Emit clickEvent\n *   end\n *\n * @example\n * <ngx-decaf-list\n *   [source]=\"dataSource\"\n *   [limit]=\"10\"\n *   [type]=\"'infinite'\"\n *   [showSearchbar]=\"true\"\n *   (clickEvent)=\"handleItemClick($event)\"\n *   (refreshEvent)=\"handleRefresh($event)\">\n * </ngx-decaf-list>\n *\n * @extends {NgxBaseComponent}\n * @implements {OnInit}\n */\n@Dynamic()\n@Component({\n  selector: 'ngx-decaf-list',\n  templateUrl: './list.component.html',\n  styleUrls: ['./list.component.scss'],\n  standalone: true,\n  imports: [\n    ForAngularModule,\n    IonRefresher,\n    IonLoading,\n    PaginationComponent,\n    IonList,\n    IonItem,\n    IonThumbnail,\n    IonSkeletonText,\n    IonLabel,\n    IonText,\n    IonRefresherContent,\n    IonInfiniteScroll,\n    IonInfiniteScrollContent,\n    IonThumbnail,\n    IonSkeletonText,\n    SearchbarComponent,\n    EmptyStateComponent,\n    ListItemComponent,\n    FilterComponent,\n    ComponentRendererComponent\n  ]\n})\nexport class ListComponent extends NgxBaseComponent implements OnInit, OnDestroy {\n\n  /**\n   * @description The display mode for the list component.\n   * @summary Determines how the list data is loaded and displayed. Options include:\n   * - INFINITE: Loads more data as the user scrolls (infinite scrolling)\n   * - PAGINATED: Displays data in pages with navigation controls\n   *\n   * @type {ListComponentsTypes}\n   * @default ListComponentsTypes.INFINITE\n   * @memberOf ListComponent\n   */\n  @Input()\n  type: ListComponentsTypes = ListComponentsTypes.INFINITE;\n\n  /**\n   * @description Controls whether the component uses translation services.\n   * @summary When set to true, the component will attempt to use translation services\n   * for any text content. This allows for internationalization of the list component.\n   *\n   * @type {StringOrBoolean}\n   * @default true\n   * @memberOf ListComponent\n   */\n  @Input()\n  override translatable: StringOrBoolean = true;\n\n  /**\n   * @description Controls the visibility of the search bar.\n   * @summary When set to true, displays a search bar at the top of the list that allows\n   * users to filter the list items. The search functionality works by filtering the\n   * existing data or by triggering a new data fetch with search parameters.\n   *\n   * @type {StringOrBoolean}\n   * @default true\n   * @memberOf ListComponent\n   */\n  @Input()\n  showSearchbar: StringOrBoolean = true;\n\n  /**\n   * @description Direct data input for the list component.\n   * @summary Provides a way to directly pass data to the list component instead of\n   * fetching it from a source. When both data and source are provided, the component\n   * will use the source to fetch data only if the data array is empty.\n   *\n   * @type {KeyValue[] | undefined}\n   * @default undefined\n   * @memberOf ListComponent\n   */\n  @Input()\n  data?: KeyValue[] | undefined = undefined;\n\n  /**\n   * @description The data source for the list component.\n   * @summary Specifies where the list should fetch its data from. This can be either:\n   * - A string URL or endpoint identifier\n   * - A function that returns data when called\n   * The component will call this source when it needs to load or refresh data.\n   *\n   * @type {string | FunctionLike}\n   * @required\n   * @memberOf ListComponent\n   */\n  @Input()\n  source!: string | FunctionLike;\n\n  /**\n   * @description The starting index for data fetching.\n   * @summary Specifies the index from which to start fetching data. This is used\n   * for pagination and infinite scrolling to determine which subset of data to load.\n   *\n   * @type {number}\n   * @default 0\n   * @memberOf ListComponent\n   */\n  @Input()\n  start: number = 0;\n\n  /**\n   * @description The number of items to fetch per page or load operation.\n   * @summary Determines how many items are loaded at once during pagination or\n   * infinite scrolling. This affects the size of data chunks requested from the source.\n   *\n   * @type {number}\n   * @default 10\n   * @memberOf ListComponent\n   */\n  @Input()\n  limit: number = 10;\n\n  /**\n   * @description Controls whether more data can be loaded.\n   * @summary When set to true, the component will allow loading additional data\n   * through infinite scrolling or pagination. When false, the component will not\n   * attempt to load more data beyond what is initially displayed.\n   *\n   * @type {StringOrBoolean}\n   * @default true\n   * @memberOf ListComponent\n   */\n  @Input()\n  loadMoreData: StringOrBoolean = true\n\n  /**\n   * @description The style of dividing lines between list items.\n   * @summary Determines how dividing lines appear between list items. Options include:\n   * - \"inset\": Lines are inset from the edges\n   * - \"full\": Lines extend the full width\n   * - \"none\": No dividing lines\n   *\n   * @type {\"inset\" | \"full\" | \"none\"}\n   * @default \"full\"\n   * @memberOf ListComponent\n   */\n  @Input()\n  lines: \"inset\" | \"full\" | \"none\" = \"full\";\n\n  /**\n   * @description Controls whether the list has inset styling.\n   * @summary When set to true, the list will have inset styling with rounded corners\n   * and margin around the edges. This creates a card-like appearance for the list.\n   *\n   * @type {StringOrBoolean}\n   * @default false\n   * @memberOf ListComponent\n   */\n  @Input()\n  inset: StringOrBoolean = false;\n\n  /**\n   * @description The threshold for triggering infinite scroll loading.\n   * @summary Specifies how close to the bottom of the list the user must scroll\n   * before the component triggers loading of additional data. This is expressed\n   * as a percentage of the list height.\n   *\n   * @type {string}\n   * @default \"15%\"\n   * @memberOf ListComponent\n   */\n  @Input()\n  scrollThreshold: string = \"15%\";\n\n  /**\n   * @description The position where new items are added during infinite scrolling.\n   * @summary Determines whether new items are added to the top or bottom of the list\n   * when loading more data through infinite scrolling.\n   *\n   * @type {\"bottom\" | \"top\"}\n   * @default \"bottom\"\n   * @memberOf ListComponent\n   */\n  @Input()\n  scrollPosition: \"bottom\" | \"top\" = \"bottom\";\n\n  /**\n   * @description Custom text to display during loading operations.\n   * @summary Specifies the text shown in the loading indicator when the component\n   * is fetching data. If not provided, a default loading message will be used.\n   *\n   * @type {string | undefined}\n   * @memberOf ListComponent\n   */\n  @Input()\n  loadingText?: string;\n\n  /**\n   * @description Controls the visibility of the pull-to-refresh feature.\n   * @summary When set to true, enables the pull-to-refresh functionality that allows\n   * users to refresh the list data by pulling down from the top of the list.\n   *\n   * @type {StringOrBoolean}\n   * @default true\n   * @memberOf ListComponent\n   */\n  @Input()\n  showRefresher: StringOrBoolean = true;\n\n  /**\n   * @description The type of spinner to display during loading operations.\n   * @summary Specifies the visual style of the loading spinner shown during data\n   * fetching operations. Uses Ionic's predefined spinner types.\n   *\n   * @type {SpinnerTypes}\n   * @default \"circular\"\n   * @memberOf ListComponent\n   */\n  @Input()\n  loadingSpinner: SpinnerTypes = \"circular\";\n\n  // /**\n  //  * @description Query parameters for data fetching.\n  //  * @summary Specifies additional query parameters to use when fetching data from\n  //  * the source. This can be provided as a string (JSON) or a direct object.\n  //  *\n  //  * @type {string | KeyValue | undefined}\n  //  * @memberOf ListComponent\n  //  */\n  // @Input()\n  // query?: string | KeyValue;\n\n  /**\n   * @description Controls whether the filtering functionality is enabled.\n   * @summary When set to true, enables the filter component that allows users to create\n   * complex search criteria with multiple field filters, conditions, and values.\n   * When false, disables the filter interface entirely.\n   *\n   * @type {StringOrBoolean}\n   * @default true\n   * @memberOf ListComponent\n   */\n  @Input()\n  enableFilter: StringOrBoolean = true;\n\n  /**\n   * @description Sorting parameters for data fetching.\n   * @summary Specifies how the fetched data should be sorted. This can be provided\n   * as a string (field name with optional direction) or a direct object.\n   *\n   * @type {string | KeyValue | undefined}\n   * @memberOf ListComponent\n   */\n  @Input()\n  sortDirection: OrderDirection = OrderDirection.DSC;\n\n\n  /**\n   * @description Sorting parameters for data fetching.\n   * @summary Specifies how the fetched data should be sorted. This can be provided\n   * as a string (field name with optional direction) or a direct object.\n   *\n   * @type {string | KeyValue | undefined}\n   * @memberOf ListComponent\n   */\n  @Input()\n  sortBy!: string;\n\n\n  /**\n   * @description Controls whether sorting functionality is disabled.\n   * @summary When set to true, disables the sort controls and prevents users from\n   * changing the sort order or field. The list will maintain its default or\n   * programmatically set sort configuration without user interaction.\n   *\n   * @type {StringOrBoolean}\n   * @default false\n   * @memberOf ListComponent\n   */\n  @Input()\n  disableSort: StringOrBoolean = false;\n\n\n  /**\n   * @description Icon to display when the list is empty.\n   * @summary Specifies the icon shown in the empty state when no data is available.\n   * This can be any icon name supported by the application's icon system.\n   *\n   * @type {string | undefined}\n   * @default 'ti-database-exclamation'\n   * @memberOf ListComponent\n   */\n  @Input()\n  emptyIcon?: string = 'ti-database-exclamation';\n\n  /**\n   * @description Configuration for the empty state display.\n   * @summary Customizes how the empty state is displayed when no data is available.\n   * This includes the title, subtitle, button text, icon, and navigation link.\n   *\n   * @type {Partial<IListEmptyResult>}\n   * @default {\n   *   title: 'empty.title',\n   *   subtitle: 'empty.subtitle',\n   *   showButton: false,\n   *   icon: 'alert-circle-outline',\n   *   buttonText: 'locale.empty.button',\n   *   link: ''\n   * }\n   * @memberOf ListComponent\n   */\n  @Input()\n  empty: Partial<IListEmptyResult> = {\n    title: 'empty.title',\n    subtitle: 'empty.subtitle',\n    showButton: false,\n    icon: 'alert-circle-outline',\n    buttonText: 'locale.empty.button',\n    link: ''\n  }\n\n  /**\n   * @description The current page number in paginated mode.\n   * @summary Tracks which page is currently being displayed when the component\n   * is in paginated mode. This is used for pagination controls and data fetching.\n   *\n   * @type {number}\n   * @default 1\n   * @memberOf ListComponent\n   */\n  page: number = 1;\n\n  /**\n   * @description The total number of pages available.\n   * @summary Stores the calculated total number of pages based on the data size\n   * and limit. This is used for pagination controls and boundary checking.\n   *\n   * @type {number}\n   * @memberOf ListComponent\n   */\n  pages!: number;\n\n  /**\n   * @description Indicates whether a refresh operation is in progress.\n   * @summary When true, the component is currently fetching new data. This is used\n   * to control loading indicators and prevent duplicate refresh operations from\n   * being triggered simultaneously.\n   *\n   * @type {boolean}\n   * @default false\n   * @memberOf ListComponent\n   */\n  refreshing: boolean = false;\n\n  /**\n   * @description Array used for rendering skeleton loading placeholders.\n   * @summary Contains placeholder items that are displayed during data loading.\n   * The length of this array determines how many skeleton items are shown.\n   *\n   * @type {string[]}\n   * @default new Array(2)\n   * @memberOf ListComponent\n   */\n  skeletonData: string[] = new Array(2);\n\n  /**\n   * @description The processed list items ready for display.\n   * @summary Stores the current set of items being displayed in the list after\n   * processing from the raw data source. This may be a subset of the full data\n   * when using pagination or infinite scrolling.\n   *\n   * @type {KeyValue[]}\n   * @memberOf ListComponent\n   */\n  items!: KeyValue[];\n\n  /**\n   * @description The current search query value.\n   * @summary Stores the text entered in the search bar. This is used to filter\n   * the list data or to send as a search parameter when fetching new data.\n   *\n   * @type {string | undefined}\n   * @memberOf ListComponent\n   */\n  searchValue?: string | IFilterQuery | undefined;\n\n  /**\n   * @description A paginator object for handling pagination operations.\n   * @summary Provides a paginator object that can be used to retrieve and navigate\n   * through data in chunks, reducing memory usage and improving performance.\n   *\n   * The paginator object is initialized in the `ngOnInit` lifecycle hook and is\n   * used to fetch and display data in the pagination component. It is an instance\n   * of the `Paginator` class from the `@decaf-ts/core` package, which provides\n   * methods for querying and manipulating paginated data.\n   *\n   * @type {Paginator<Model>}\n   * @memberOf PaginationComponent\n   */\n  paginator!: Paginator<Model> | undefined;\n\n  /**\n   * @description The last page number that was displayed.\n   * @summary Keeps track of the previously displayed page number, which is useful\n   * for handling navigation and search operations in paginated mode.\n   *\n   * @type {number}\n   * @default 1\n   * @memberOf ListComponent\n   */\n  lastPage: number = 1\n\n  /**\n   * @description Event emitter for refresh operations.\n   * @summary Emits an event when the list data is refreshed, either through pull-to-refresh\n   * or programmatic refresh. The event includes the refreshed data and component information.\n   *\n   * @type {EventEmitter<BaseCustomEvent>}\n   * @memberOf ListComponent\n   */\n  @Output()\n  refreshEvent: EventEmitter<BaseCustomEvent> = new EventEmitter<BaseCustomEvent>();\n\n  /**\n   * @description Event emitter for item click interactions.\n   * @summary Emits an event when a list item is clicked. The event includes the data\n   * of the clicked item, allowing parent components to respond to the interaction.\n   *\n   * @type {EventEmitter<KeyValue>}\n   * @memberOf ListComponent\n   */\n  @Output()\n  clickEvent:  EventEmitter<ListItemCustomEvent|RendererCustomEvent> = new EventEmitter<ListItemCustomEvent|RendererCustomEvent>();\n\n  /**\n   * @description Subject for debouncing click events.\n   * @summary Uses RxJS Subject to collect click events and emit them after a debounce\n   * period. This prevents multiple rapid clicks from triggering multiple events.\n   *\n   * @private\n   * @type {Subject<CustomEvent | ListItemCustomEvent | RendererCustomEvent>}\n   * @memberOf ListComponent\n   */\n  private clickItemSubject: Subject<CustomEvent | ListItemCustomEvent | RendererCustomEvent> = new Subject<CustomEvent | ListItemCustomEvent | RendererCustomEvent>();\n\n\n  /**\n   * @description Subject for debouncing repository observation events.\n   * @summary RxJS Subject that collects repository change events and emits them after\n   * a debounce period. This prevents multiple rapid repository changes from triggering\n   * multiple list refresh operations, improving performance and user experience.\n   *\n   * @private\n   * @type {Subject<any>}\n   * @memberOf ListComponent\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private observerSubjet: Subject<any> = new Subject<any>();\n\n  /**\n   * @description Observer object for repository change notifications.\n   * @summary Implements the Observer interface to receive notifications when the\n   * underlying data repository changes. This enables automatic list updates when\n   * data is created, updated, or deleted through the repository.\n   *\n   * @private\n   * @type {Observer}\n   * @memberOf ListComponent\n   */\n  private observer: Observer = { refresh: async (... args: unknown[]): Promise<void> => this.observeRepository(...args)}\n\n  /**\n   * @description List of available indexes for data querying and filtering.\n   * @summary Provides a list of index names that can be used to optimize data querying and filtering\n   * operations, especially in scenarios with large datasets.\n   *\n   * Indexes can significantly improve the performance of data retrieval by allowing the database\n   * to quickly locate and retrieve relevant data based on indexed fields.\n   *\n   * @type {string[]}\n   * @default []\n   * @memberOf ListComponent\n   */\n  indexes!: string[];\n\n  /**\n   * @description Initializes a new instance of the ListComponent.\n   * @summary Creates a new ListComponent and sets up the base component with the appropriate\n   * component name. This constructor is called when Angular instantiates the component and\n   * before any input properties are set. It passes the component name to the parent class\n   * constructor to enable proper localization and component identification.\n   *\n   * The constructor is intentionally minimal, with most initialization logic deferred to\n   * the ngOnInit lifecycle hook. This follows Angular best practices by keeping the constructor\n   * focused on dependency injection and basic setup, while complex initialization that depends\n   * on input properties is handled in ngOnInit.\n   *\n   * @memberOf ListComponent\n   */\n  constructor() {\n    super(\"ListComponent\");\n  }\n\n\n  /**\n   * @description Initializes the component after Angular sets the input properties.\n   * @summary Sets up the component by initializing event subscriptions, processing boolean\n   * inputs, and loading the initial data. This method prepares the component for user\n   * interaction by ensuring all properties are properly initialized and data is loaded.\n   *\n   * @returns {Promise<void>}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant L as ListComponent\n   *   participant D as Data Source\n   *\n   *   A->>L: ngOnInit()\n   *   L->>L: Set up click event debouncing\n   *   L->>L: Process boolean inputs\n   *   L->>L: Configure component based on inputs\n   *   L->>L: refresh()\n   *   L->>D: Request initial data\n   *   D-->>L: Return data\n   *   L->>L: Process and display data\n   *   L->>L: Configure empty state if needed\n   *   L->>L: initialize()\n   *\n   * @memberOf ListComponent\n   */\n  async ngOnInit(): Promise<void> {\n    this.clickItemSubject.pipe(debounceTime(100)).subscribe(event => this.clickEventEmit(event as ListItemCustomEvent | RendererCustomEvent));\n    this.observerSubjet.pipe(debounceTime(100)).subscribe(args => this.handleObserveEvent(args[0], args[1], args[2]));\n    this.enableFilter = stringToBoolean(this.enableFilter);\n    this.limit = Number(this.limit);\n    this.start = Number(this.start);\n    this.inset = stringToBoolean(this.inset);\n    this.showRefresher = stringToBoolean(this.showRefresher);\n    this.loadMoreData = stringToBoolean(this.loadMoreData);\n    this.showSearchbar = stringToBoolean(this.showSearchbar);\n    this.disableSort = stringToBoolean(this.disableSort);\n    if(typeof this.item?.['tag'] === 'boolean' && this.item?.['tag'] === true)\n      this.item['tag'] = ComponentsTagNames.LIST_ITEM as string;\n\n    await this.refresh();\n\n    if(this.operations.includes(OperationKeys.CREATE) && this.route)\n      this.empty.link = `${this.route}/${OperationKeys.CREATE}`;\n\n    this.initialize();\n\n    if(this.model instanceof Model && this._repository)\n      this._repository.observe(this.observer);\n  }\n\n  /**\n   * @description Cleans up resources when the component is destroyed.\n   * @summary Performs cleanup operations when the component is being removed from the DOM.\n   * This includes clearing references to models and data to prevent memory leaks.\n   *\n   * @returns {void}\n   * @memberOf ListComponent\n   */\n  ngOnDestroy(): void {\n    if(this._repository)\n      this._repository.unObserve(this.observer);\n    this.data =  this.model = this._repository = this.paginator = undefined;\n  }\n\n  /**\n   * @description Handles repository observation events with debouncing.\n   * @summary Processes repository change notifications and routes them appropriately.\n   * For CREATE events with a UID, handles them immediately. For other events,\n   * passes them to the debounced observer subject to prevent excessive updates.\n   *\n   * @param {...unknown[]} args - The repository event arguments including table, event type, and UID\n   * @returns {Promise<void>}\n   * @memberOf ListComponent\n   */\n  async observeRepository(...args: unknown[]): Promise<void> {\n    const [table, event, uid] = args;\n    if(event === OperationKeys.CREATE && !!uid)\n      return this.handleObserveEvent(table as string, event, uid as string | number);\n    return this.observerSubjet.next(args);\n  }\n\n  /**\n   * @description Handles specific repository events and updates the list accordingly.\n   * @summary Processes repository change events (CREATE, UPDATE, DELETE) and performs\n   * the appropriate list operations. This includes adding new items, updating existing\n   * ones, or removing deleted items from the list display.\n   *\n   * @param {string} table - The table/model name that changed\n   * @param {OperationKeys} event - The type of operation (CREATE, UPDATE, DELETE)\n   * @param {string | number} uid - The unique identifier of the affected item\n   * @returns {Promise<void>}\n   * @memberOf ListComponent\n   */\n  async handleObserveEvent(table: string, event: OperationKeys, uid: string | number): Promise<void> {\n    if(event === OperationKeys.CREATE) {\n      if(uid) {\n        await this.handleCreate(uid);\n      } else {\n        await this.refresh(true);\n      }\n    } else {\n      if(event === OperationKeys.UPDATE)\n        await this.handleUpdate(uid);\n      if(event === OperationKeys.DELETE)\n        this.handleDelete(uid);\n      this.refreshEventEmit();\n    }\n  }\n\n\n  /**\n   * @description Function for tracking items in the list.\n   * @summary Provides a tracking function for the `*ngFor` directive in the component template.\n   * This function is used to identify and control the rendering of items in the list,\n   * preventing duplicate or unnecessary rendering.\n   *\n   * The `trackItemFn` function takes two parameters: `index` (the index of the item in the list)\n   * and `item` (the actual item from the list). It returns the tracking key, which in this case\n   * is the union of the `uid` of the item with the model name.\n   *\n   * @param {number} index - The index of the item in the list.\n\n   * @param {KeyValue | string | number} item - The actual item from the list.\n   * @returns {string | number} The tracking key for the item.\n   * @memberOf ListComponent\n   */\n  override trackItemFn(index: number, item: KeyValue | string | number): string | number {\n    return `${ (item as KeyValue)?.['uid'] || (item as KeyValue)?.[this.pk]}-${index}`;\n  }\n\n\n  /**\n   * Handles the create event from the repository.\n   *\n   * @param {string | number} uid - The ID of the item to create.\n   * @returns {Promise<void>} A promise that resolves when the item is created and added to the list.\n   */\n  async handleCreate(uid: string | number): Promise<void> {\n    const result = await this._repository?.read(uid);\n    const item = this.mapResults([result as KeyValue])[0];\n    this.items = this.data = [item, ...this.items || []];\n  }\n\n\n  /**\n   * @description Handles the update event from the repository.\n   * @summary Updates the list item with the specified ID based on the new data.\n   *\n   * @param {string | number} uid - The ID of the item to update\n   * @returns {Promise<void>}\n   * @private\n   * @memberOf ListComponent\n   */\n  async handleUpdate(uid: string | number): Promise<void> {\n    const item: KeyValue = this.itemMapper(await this._repository?.read(uid) || {}, this.mapper);\n    this.data = [];\n    for(const key in this.items as KeyValue[]) {\n        const child = this.items[key] as KeyValue;\n        if(child['uid'] === item['uid']) {\n          this.items[key] = Object.assign({}, child, item);\n          break;\n        }\n    }\n    setTimeout(() => {\n      this.data = [ ...this.items];\n    }, 0);\n  }\n\n  /**\n   * @description Removes an item from the list by ID.\n   * @summary Filters out an item with the specified ID from the data array and\n   * refreshes the list display. This is typically used after a delete operation.\n   *\n   * @param {string} uid - The ID of the item to delete\n   * @param {string} pk - The primary key field name\n   * @returns {Promise<void>}\n   *\n   * @memberOf ListComponent\n   */\n  handleDelete(uid: string | number, pk?: string): void  {\n    if(!pk)\n      pk = this.pk;\n    this.items = this.data?.filter((item: KeyValue) => item['uid'] !== uid) || [];\n  }\n\n\n  /**\n   * @description Handles click events from list items.\n   * @summary Listens for global ListItemClickEvent events and passes them to the\n   * debounced click subject. This allows the component to respond to clicks on\n   * list items regardless of where they originate from.\n   *\n   * @param {ListItemCustomEvent | RendererCustomEvent} event - The click event\n   * @returns {void}\n   *\n   * @memberOf ListComponent\n   */\n  @HostListener('window:ListItemClickEvent', ['$event'])\n  handleClick(event: ListItemCustomEvent | RendererCustomEvent): void {\n    this.clickItemSubject.next(event);\n  }\n\n  /**\n   * @description Handles search events from the search bar.\n   * @summary Processes search queries from the search bar component, updating the\n   * displayed data based on the search term. The behavior differs between infinite\n   * and paginated modes to provide the best user experience for each mode.\n   *\n   * @param {string | undefined} value - The search term or undefined to clear search\n   * @returns {Promise<void>}\n   *\n   * @mermaid\n   * flowchart TD\n   *   A[Search Event] --> B{Type is Infinite?}\n   *   B -->|Yes| C[Disable loadMoreData]\n   *   B -->|No| D[Enable loadMoreData]\n   *   C --> E{Search value undefined?}\n   *   E -->|Yes| F[Enable loadMoreData]\n   *   E -->|No| G[Store search value]\n   *   D --> G\n   *   F --> H[Reset page to 1]\n   *   G --> I[Refresh data]\n   *   H --> I\n   *\n   * @memberOf ListComponent\n   */\n  @HostListener('window:searchbarEvent', ['$event'])\n  async handleSearch(value: string | IFilterQuery | undefined): Promise<void> {\n    if(this.type === ListComponentsTypes.INFINITE) {\n      this.loadMoreData = false;\n      if(value === undefined) {\n        this.loadMoreData = true;\n        this.page = 1;\n      }\n      this.searchValue = value;\n      await this.refresh(true);\n    } else {\n      this.loadMoreData = true;\n      this.searchValue = value;\n      if(value === undefined)\n        this.page = this.lastPage;\n      await this.refresh(true);\n    }\n  }\n\n\n  /**\n   * @description Handles filter events from the filter component.\n   * @summary Processes filter queries from the filter component and applies them\n   * to the list data. This method acts as a bridge between the filter component\n   * and the search functionality, converting filter queries into search operations.\n   *\n   * @param {IFilterQuery | undefined} value - The filter query object or undefined to clear filters\n   * @returns {Promise<void>}\n   * @memberOf ListComponent\n   */\n  async handleFilter(value: IFilterQuery | undefined): Promise<void> {\n    await this.handleSearch(value);\n  }\n\n  /**\n   * @description Clears the current search and resets the list.\n   * @summary Convenience method that clears the search by calling handleSearch\n   * with undefined. This resets the list to show all data without filtering.\n   *\n   * @returns {Promise<void>}\n   * @memberOf ListComponent\n   */\n  async clearSearch(): Promise<void> {\n    await this.handleSearch(undefined);\n  }\n\n  /**\n   * @description Emits a refresh event with the current data.\n   * @summary Creates and emits a refresh event containing the current list data.\n   * This notifies parent components that the list data has been refreshed.\n   *\n   * @param {KeyValue[]} [data] - Optional data to include in the event\n   * @returns {void}\n   *\n   * @memberOf ListComponent\n   */\n  refreshEventEmit(data?: KeyValue[]): void {\n    if(!data)\n      data = this.items;\n    this.skeletonData = new Array(data?.length || 2);\n    this.refreshEvent.emit({\n      name: EventConstants.REFRESH_EVENT,\n      data: data || [],\n      component: this.componentName\n    });\n  }\n\n  /**\n   * @description Emits a click event for a list item.\n   * @summary Processes and emits a click event when a list item is clicked.\n   * This extracts the relevant data from the event and passes it to parent components.\n   *\n   * @private\n   * @param {ListItemCustomEvent | RendererCustomEvent} event - The click event\n   * @returns {void}\n   *\n   * @memberOf ListComponent\n   */\n  private clickEventEmit(event: ListItemCustomEvent | RendererCustomEvent): void {\n    this.clickEvent.emit(event);\n  }\n\n  /**\n   * @description Refreshes the list data from the configured source.\n   * @summary This method handles both initial data loading and subsequent refresh operations,\n   * including pull-to-refresh and infinite scrolling. It manages the data fetching process,\n   * updates the component's state, and handles pagination or infinite scrolling logic based\n   * on the component's configuration.\n   *\n   * The method performs the following steps:\n   * 1. Sets the refreshing flag to indicate a data fetch is in progress\n   * 2. Calculates the appropriate start and limit values based on pagination settings\n   * 3. Fetches data from the appropriate source (model or request)\n   * 4. Updates the component's data and emits a refresh event\n   * 5. Handles pagination or infinite scrolling state updates\n   * 6. Completes any provided event (like InfiniteScrollCustomEvent)\n   *\n   * @param {InfiniteScrollCustomEvent | RefresherCustomEvent | boolean} event - The event that triggered the refresh,\n   * or a boolean flag indicating if this is a forced refresh\n   * @returns {Promise<void>} A promise that resolves when the refresh operation is complete\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant L as ListComponent\n   *   participant D as Data Source\n   *   participant E as Event System\n   *\n   *   L->>L: refresh(event)\n   *   L->>L: Set refreshing flag\n   *   L->>L: Calculate start and limit\n   *   alt Using model\n   *     L->>D: getFromModel(force, start, limit)\n   *     D-->>L: Return data\n   *   else Using request\n   *     L->>D: getFromRequest(force, start, limit)\n   *     D-->>L: Return data\n   *   end\n   *   L->>E: refreshEventEmit()\n   *   alt Infinite scrolling mode\n   *     L->>L: Check if reached last page\n   *     alt Last page reached\n   *       L->>L: Complete scroll event\n   *       L->>L: Disable loadMoreData\n   *     else More pages available\n   *       L->>L: Increment page number\n   *       L->>L: Complete scroll event after delay\n   *     end\n   *   else Paginated mode\n   *     L->>L: Clear refreshing flag after delay\n   *   end\n   *\n   * @memberOf ListComponent\n   */\n  @HostListener('window:BackButtonNavigationEndEvent', ['$event'])\n  async refresh(event: InfiniteScrollCustomEvent | RefresherCustomEvent | boolean = false): Promise<void> {\n    //  if(typeof force !== 'boolean' && force.type === EventConstants.BACK_BUTTON_NAVIGATION) {\n    //    const {refresh} = (force as CustomEvent).detail;\n    //    if(!refresh)\n    //      return false;\n    //  }\n\n    this.refreshing = true;\n    const start: number = this.page > 1 ? (this.page - 1) * this.limit : this.start;\n    const limit: number = (this.page * (this.limit > 12 ? 12 : this.limit));\n\n    this.data = !this.model ?\n      await this.getFromRequest(!!event, start, limit)\n      : await this.getFromModel(!!event) as KeyValue[];\n\n    this.refreshEventEmit();\n\n    if(this.type === ListComponentsTypes.INFINITE) {\n      if(this.page === this.pages) {\n        if((event as InfiniteScrollCustomEvent)?.target)\n          (event as InfiniteScrollCustomEvent).target.complete();\n        this.loadMoreData = false;\n      } else {\n        this.page += 1;\n        this.refreshing = false;\n        setTimeout(() => {\n            if((event as InfiniteScrollCustomEvent)?.target && (event as CustomEvent)?.type !== EventConstants.BACK_BUTTON_NAVIGATION)\n              (event as InfiniteScrollCustomEvent).target.complete();\n        }, 200);\n      }\n    } else {\n      setTimeout(() => {\n        this.refreshing = false;\n      }, 200)\n    }\n  }\n\n  /**\n * @description Handles pagination events from the pagination component.\n * @summary Processes pagination events by updating the current page number and\n * refreshing the list data to display the selected page. This method is called\n * when a user interacts with the pagination controls to navigate between pages.\n *\n * @param {PaginationCustomEvent} event - The pagination event containing page information\n * @returns {void}\n *\n * @memberOf ListComponent\n */\nhandlePaginate(event: PaginationCustomEvent): void {\n  const { page} = event.data;\n  this.page = page;\n  this.refresh(true);\n}\n\n/**\n * @description Handles pull-to-refresh events from the refresher component.\n * @summary Processes refresh events triggered by the user pulling down on the list\n * or by programmatic refresh requests. This method refreshes the list data and\n * completes the refresher animation when the data is loaded.\n *\n * @param {InfiniteScrollCustomEvent | CustomEvent} [event] - The refresh event\n * @returns {Promise<void>} A promise that resolves when the refresh operation is complete\n *\n * @memberOf ListComponent\n */\nasync handleRefresh(event?: InfiniteScrollCustomEvent | CustomEvent): Promise<void> {\n  await this.refresh(event as InfiniteScrollCustomEvent || true);\n  if(event instanceof CustomEvent)\n    setTimeout(() => {\n      // Any calls to load data go here\n      (event.target as HTMLIonRefresherElement).complete();\n    }, 400);\n}\n\n/**\n * @description Filters data based on a search string.\n * @summary Processes the current data array to find items that match the provided\n * search string. This uses the arrayQueryByString utility to perform the filtering\n * across all properties of the items.\n *\n * @param {KeyValue[]} results - The array of items to search through\n * @param {string} search - The search string to filter by\n * @returns {KeyValue[]} A promise that resolves to the filtered array of items\n *\n * @memberOf ListComponent\n */\n  parseSearchResults(results: KeyValue[], search: string): KeyValue[] {\n    return results.filter((item: KeyValue) =>\n      Object.values(item).some(value =>\n          value.toString().toLowerCase().includes((search as string)?.toLowerCase())\n        )\n    );\n  }\n\n/**\n * @description Fetches data from a request source.\n * @summary Retrieves data from the configured source function or URL, processes it,\n * and updates the component's data state. This method handles both initial data loading\n * and subsequent refresh operations when using an external data source rather than a model.\n *\n * @param {boolean} force - Whether to force a refresh even if data already exists\n * @param {number} start - The starting index for pagination\n * @param {number} limit - The maximum number of items to retrieve\n * @returns {Promise<KeyValue[]>} A promise that resolves to the fetched data\n *\n * @memberOf ListComponent\n */\nasync getFromRequest(force: boolean = false, start: number, limit: number): Promise<KeyValue[]> {\n  let request: KeyValue[] = [];\n  if(!this.data?.length || force || (this.searchValue as string)?.length || !!(this.searchValue as IFilterQuery)) {\n    // (self.data as ListItem[]) = [];\n    if(!(this.searchValue as string)?.length && !(this.searchValue as IFilterQuery)) {\n      if(!this.source && !this.data?.length) {\n        this.logger.info('No data and source passed to infinite list');\n        return [];\n      }\n\n      if(this.source instanceof Function)\n        request = await this.source();\n\n      if(!Array.isArray(request))\n        request = request?.['response']?.['data'] || request?.['results'] || [];\n      this.data = [... await this.parseResult(request)];\n      if(this.data?.length)\n        this.items = this.type === ListComponentsTypes.INFINITE ?\n          (this.items || []).concat([...this.data.slice(start, limit)]) : [...request.slice(start, limit) as KeyValue[]];\n    } else {\n      this.data = this.parseSearchResults(this.data as [], this.searchValue as string);\n      this.items = this.data;\n    }\n  }\n\n  if(this.loadMoreData && this.type === ListComponentsTypes.PAGINATED)\n    this.getMoreData(this.data?.length || 0);\n  return this.data || [] as KeyValue[];\n}\n\n/**\n * @description Fetches data from a model source.\n * @summary Retrieves data from the configured model using its pagination or find methods,\n * processes it, and updates the component's data state. This method handles both initial\n * data loading and subsequent refresh operations when using a model as the data source.\n *\n * @param {boolean} force - Whether to force a refresh even if data already exists\n * @param {number} start - The starting index for pagination\n * @param {number} limit - The maximum number of items to retrieve\n * @returns {Promise<KeyValue[]>} A promise that resolves to the fetched data\n *\n * @memberOf ListComponent\n */\nasync getFromModel(force: boolean = false): Promise<KeyValue[]> {\n  let data = [ ... this.data || []];\n  let request: KeyValue[] = [];\n\n  // getting model repository\n  if(!this._repository)\n    this._repository = this.repository;\n  const repo = this._repository as DecafRepository<Model>;\n  if(!this.data?.length || force || (this.searchValue as string)?.length || !!(this.searchValue as IFilterQuery)) {\n    try {\n     if(!(this.searchValue as string)?.length && !(this.searchValue as IFilterQuery)) {\n        (this.data as KeyValue[]) = [];\n        // const rawQuery = this.parseQuery(self.model as Repository<Model>, start, limit);\n        // request = this.parseResult(await (this.model as any)?.paginate(start, limit));\n          if(!this.paginator) {\n            this.paginator = await repo\n              .select()\n              .orderBy([this.pk as keyof Model, this.sortDirection])\n              .paginate(this.limit);\n          }\n          request = await this.parseResult(this.paginator);\n      } else {\n\n        if(!this.indexes)\n          this.indexes = (Object.values(this.mapper) || [this.pk]);\n\n        const condition = this.parseConditions(this.searchValue as string | number | IFilterQuery);\n        request = await this.parseResult(await repo.query(condition, (this.sortBy || this.pk) as keyof Model, this.sortDirection));\n        data = [];\n      }\n      data = this.type === ListComponentsTypes.INFINITE ? [... (data).concat(request)] : [...request];\n    } catch(error: unknown) {\n      this.logger.error((error as Error)?.message || `Unable to find ${this.model} on registry. Return empty array from component`);\n    }\n  }\n\n  if(data?.length) {\n    if(this.searchValue) {\n      this.items = [...data];\n      if(this.items?.length <= this.limit)\n        this.loadMoreData = false;\n    } else {\n      this.items = [...data];\n    }\n  }\n  if(this.type === ListComponentsTypes.PAGINATED && this.paginator)\n      this.getMoreData(this.paginator.total);\n  return data || [] as KeyValue[];\n}\n\n/**\n * @description Converts search values or filter queries into database conditions.\n * @summary Transforms search input or complex filter queries into Condition objects\n * that can be used for database querying. Handles both simple string/number searches\n * across indexed fields and complex filter queries with multiple criteria.\n *\n * For simple searches (string/number):\n * - Creates conditions that search across all indexed fields\n * - Uses equality for numeric values and regex for string values\n * - Combines conditions with OR logic to search multiple fields\n *\n * For complex filter queries:\n * - Processes each filter item with its specific condition type\n * - Supports Equal, Not Equal, Contains, Not Contains, Greater Than, Less Than\n * - Updates sort configuration based on the filter query\n * - Combines multiple filter conditions with OR logic\n *\n * @param {string | number | IFilterQuery} value - The search value or filter query object\n * @returns {Condition<Model>} A Condition object for database querying\n * @memberOf ListComponent\n */\nparseConditions(value: string | number | IFilterQuery): Condition<Model> {\n  let _condition: Condition<Model>;\n  if(typeof value === Primitives.STRING || typeof value === Primitives.NUMBER) {\n    _condition = Condition.attribute<Model>(this.pk as keyof Model).eq(!isNaN(value as number) ? Number(value) : value);\n    for (const index of this.indexes) {\n        if(index === this.pk)\n          continue;\n        let orCondition;\n        if(!isNaN(value as number)) {\n          orCondition = Condition.attribute<Model>(index as keyof Model).eq(Number(value));\n        } else {\n          orCondition = Condition.attribute<Model>(index as keyof Model).regexp(value as string);\n        }\n        _condition = _condition.or(orCondition);\n    }\n  } else {\n    const {query, sort} = value as IFilterQuery;\n    _condition = Condition.attribute<Model>(this.pk as keyof Model).dif('null');\n\n    if(query?.length)\n      _condition = undefined as unknown as Condition<Model>;\n\n    (query || []).forEach((item: IFilterQueryItem) => {\n      const {value, condition, index} = item;\n      let val = value as string | number;\n      if(index === this.pk || !isNaN(val as number))\n        val = Number(val);\n      let orCondition;\n      switch (condition) {\n        case \"Equal\":\n          orCondition = Condition.attribute<Model>(index as keyof Model).eq(val);\n          break;\n        case \"Not Equal\":\n          orCondition = Condition.attribute<Model>(index as keyof Model).dif(val);\n          break;\n        case \"Not Contains\":\n          orCondition = !Condition.attribute<Model>(index as keyof Model).regexp(new RegExp(`^(?!.*${val}).*$`));\n          break;\n        case \"Contains\":\n          orCondition = Condition.attribute<Model>(index as keyof Model).regexp(val as string);\n          break;\n        case \"Greater Than\":\n          orCondition = Condition.attribute<Model>(index as keyof Model).gte(val);\n          break;\n        case \"Less Than\":\n          orCondition = Condition.attribute<Model>(index as keyof Model).lte(val);\n          break;\n      }\n      _condition = (!_condition ?\n        orCondition : _condition.and(orCondition as unknown as Condition<Model>)) as Condition<Model>;\n    });\n\n    this.sortBy = sort?.value as keyof Model || this.pk;\n    this.sortDirection = sort?.direction || this.sortDirection;\n  }\n  console.log(_condition);\n  return _condition as Condition<Model>;\n\n}\n\n/**\n * @description Processes query results into a standardized format.\n * @summary Handles different result formats from various data sources, extracting\n * pagination information when available and applying any configured data mapping.\n * This ensures consistent data structure regardless of the source.\n *\n * @protected\n * @param {KeyValue[] | Paginator} result - The raw query result\n * @returns {KeyValue[]} The processed array of items\n *\n * @memberOf ListComponent\n */\nprotected async parseResult(result: KeyValue[] | Paginator<Model>): Promise<KeyValue[]> {\n  if(!Array.isArray(result) && ('page' in result && 'total' in result)) {\n    const paginator = result as Paginator<Model>;\n    result = await paginator.page(this.page);\n    // TODO: Chage for result.total;\n    this.getMoreData(paginator.total);\n  } else {\n    this.getMoreData((result as KeyValue[])?.length || 0);\n  }\n  return (Object.keys(this.mapper || {}).length) ?\n    this.mapResults(result) : result;\n}\n\n/**\n * @description Updates pagination state based on data length.\n * @summary Calculates whether more data is available and how many pages exist\n * based on the total number of items and the configured limit per page.\n * This information is used to control pagination UI and infinite scrolling behavior.\n *\n * @param {number} length - The total number of items available\n * @returns {void}\n *\n * @memberOf ListComponent\n */\ngetMoreData(length: number): void {\n  if(this.type === ListComponentsTypes.INFINITE) {\n    if(this.paginator)\n      length = length * this.limit;\n    if(length <= this.limit) {\n      this.loadMoreData = false;\n    } else {\n      this.pages = Math.floor(length / this.limit);\n      if((this.pages * this.limit) < length)\n        this.pages += 1;\n      if(this.pages === 1)\n        this.loadMoreData = false;\n    }\n  } else {\n    this.pages = length;\n    if(this.pages === 1)\n      this.loadMoreData = false;\n  }\n}\n\n/**\n * @description Maps a single item using the configured mapper.\n * @summary Transforms a data item according to the mapping configuration,\n * extracting nested properties and formatting values as needed. This allows\n * the component to display data in a format different from how it's stored.\n *\n * @protected\n * @param {KeyValue} item - The item to map\n * @param {KeyValue} mapper - The mapping configuration\n * @param {KeyValue} [props] - Additional properties to include\n * @returns {KeyValue} The mapped item\n *\n * @memberOf ListComponent\n */\nprotected itemMapper(item: KeyValue, mapper: KeyValue, props?: KeyValue): KeyValue {\n  return Object.entries(mapper).reduce((accum: KeyValue, [key, value]) => {\n    const arrayValue = value.split('.');\n    if (!value) {\n      accum[key] = value;\n    } else {\n      if (arrayValue.length === 1) {\n        value = item?.[value] || value;\n        if(isValidDate(value))\n          value = `${formatDate(value)}`;\n        accum[key] = value;\n      } else {\n        let val;\n\n        for (const _value of arrayValue)\n          val = !val\n            ? item[_value]\n            : (typeof val === 'string' ? JSON.parse(val) : val)[_value];\n\n\n        if (isValidDate(new Date(val)))\n          val = `${formatDate(val)}`;\n\n        accum[key] = val === null || val === undefined ? value : val;\n      }\n    }\n    return Object.assign({}, props || {}, accum);\n  }, {});\n}\n\n/**\n * @description Maps all result items using the configured mapper.\n * @summary Applies the itemMapper to each item in the result set, adding\n * common properties like operations and route information. This transforms\n * the raw data into the format expected by the list item components.\n *\n * @param {KeyValue[]} data - The array of items to map\n * @returns {KeyValue[]} The array of mapped items\n *\n * @memberOf ListComponent\n */\n  mapResults(data: KeyValue[]): KeyValue[] {\n    if(!data || !data.length)\n      return [];\n    // passing uid as prop to mapper\n    this.mapper = {... this.mapper, ... {uid: this.pk}};\n    const props = Object.assign({\n      operations: this.operations,\n      route: this.route,\n      ...  Object.keys(this.item).reduce((acc: KeyValue, key: string) => {\n        acc[key] = this.item[key];\n        return acc;\n      }, {}),\n      // ... (!this.item.render ? {} :  Object.keys(this.item).reduce((acc: KeyValue, key: string) => {\n      //   acc[key] = this.item[key as keyof IListItemProp];\n      //   return acc;\n      // }, {}))\n    });\n    return data.reduce((accum: KeyValue[], curr) => {\n        accum.push({... this.itemMapper(curr, this.mapper as KeyValue, props), ... {pk: this.pk}});\n        return accum;\n    }, []);\n  }\n}\n\n","\n@if(showRefresher) {\n  <ion-refresher slot=\"fixed\" [pullFactor]=\"1\" [pullMin]=\"100\" [pullMax]=\"200\" (ionRefresh)=\"handleRefresh($event)\">\n    <ion-refresher-content />\n  </ion-refresher>\n}\n\n@if(showSearchbar) {\n  @if(model && enableFilter) {\n    <ngx-decaf-filter\n      [model]=\"model\"\n      [sortDirection]=\"sortDirection\"\n      [disableSort]=\"disableSort\"\n      (filterEvent)=\"handleFilter($event)\"\n      (searchEvent)=\"handleSearch($event)\"\n    />\n  } @else {\n    <ngx-decaf-searchbar [emitEventToWindow]=\"false\" [debounce]=\"500\" (searchEvent)=\"handleSearch($event)\" />\n  }\n}\n\n@if(data?.length) {\n  <ion-list [inset]=\"inset\" [lines]=\"lines\" #component>\n    @if(item?.tag) {\n      @for(child of items; track trackItemFn($index, child)) {\n        <ngx-decaf-component-renderer\n          [tag]=\"item.tag\"\n          (listenEvent)=\"handleEvent($event)\"\n          [globals]='{\n            item: child,\n            mapper: mapper,\n            route: route\n          }'>\n          </ngx-decaf-component-renderer>\n        }\n    } @else {\n      <ng-content></ng-content>\n    }\n  </ion-list>\n\n  @if(loadMoreData) {\n    @if(pages > 0 && type === 'paginated' && !searchValue?.length) {\n      <ngx-decaf-pagination\n        [totalPages]=\"pages\"\n        [current]=\"page\"\n        (clickEvent)=\"handlePaginate($event)\"\n      />\n\n    } @else {\n      <ion-infinite-scroll\n        [class]=\"searchValue?.length ? 'dcf-hidden' : ''\"\n        [position]=\"scrollPosition\"\n        [threshold]=\"scrollThreshold\"\n        (ionInfinite)=\"handleRefresh($event)\">\n        <ion-infinite-scroll-content [loadingSpinner]=\"loadingSpinner\" [loadingText]=\"loadingText\" />\n      </ion-infinite-scroll>\n    }\n  }\n} @else {\n  @if(refreshing) {\n    <ion-item *ngFor=\"let skl of skeletonData\">\n      <ion-thumbnail slot=\"start\">\n        <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n      </ion-thumbnail>\n      <ion-label>\n        <ion-skeleton-text [animated]=\"true\"></ion-skeleton-text>\n        <ion-text class=\"date\" style=\"width: 20%;\"><ion-skeleton-text [animated]=\"true\"></ion-skeleton-text></ion-text>\n      </ion-label>\n    </ion-item>\n  } @else {\n    @if(!searchValue?.length) {\n      <ngx-decaf-empty-state\n        [title]=\"(locale + '.'+ empty.title) | translate\"\n        [subtitle]=\"(locale + '.'+ empty.subtitle) | translate\"\n        [buttonText]=\"empty.showButton ? (locale + '.'+ empty.button | translate) : ''\"\n        [buttonLink]=\"empty.showButton ? empty.route : ''\"\n      />\n    } @else {\n      <ngx-decaf-empty-state\n        icon=\"search-outline\"\n        ngClass=\"empty-search\"\n        [translatable]=\"true\"\n        title=\"search.title\"\n        subtitle=\"search.subtitle\"\n        [searchValue]=\"searchValue\"\n      />\n    }\n  }\n}\n\n"]}