@decaf-ts/for-angular 0.0.10 → 0.0.11

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

@@ -0,0 +1,689 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { ForAngularModule } from '../../for-angular.module';
+import { NgxBaseComponent } from '../../engine/NgxBaseComponent';
+import { IonChip, IonIcon, IonItem, IonLabel, IonSelect } from '@ionic/angular/standalone';
+import { Dynamic } from '../../engine';
+import { getWindowWidth } from '../../helpers/utils';
+import { debounceTime, fromEvent } from 'rxjs';
+import { OrderDirection, Repository } from '@decaf-ts/core';
+import { SearchbarComponent } from '../searchbar/searchbar.component';
+import { addIcons } from 'ionicons';
+import { chevronDownOutline, chevronUpOutline } from 'ionicons/icons';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular/standalone";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@ngx-translate/core";
+/**
+ * @description Advanced filter component for creating dynamic search filters with step-by-step construction.
+ * @summary This component provides a comprehensive filtering interface that allows users to build
+ * complex search criteria using a three-step approach: select index → select condition → enter value.
+ * It supports filtering by multiple field indexes, comparison conditions, and values, displaying
+ * selected filters as removable chips. The component is responsive and includes auto-suggestions
+ * with keyboard navigation support.
+ *
+ * @example
+ * ```html
+ * <ngx-decaf-filter
+ *   [indexes]="['name', 'email', 'department', 'status']"
+ *   [conditions]="['Equal', 'Contains', 'Greater Than', 'Less Than']"
+ *   [sort]="['createdAt', 'updatedAt']"
+ *   [disableSort]="false"
+ *   (filterEvent)="onFiltersChanged($event)">
+ * </ngx-decaf-filter>
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant U as User
+ *   participant F as FilterComponent
+ *   participant P as Parent Component
+ *
+ *   U->>F: Focus input field
+ *   F->>F: handleFocus() - Show available indexes
+ *   U->>F: Select index (e.g., "name")
+ *   F->>F: addFilter() - Step 1 completed
+ *   F->>F: Show available conditions
+ *   U->>F: Select condition (e.g., "Contains")
+ *   F->>F: addFilter() - Step 2 completed
+ *   F->>F: Show value input prompt
+ *   U->>F: Enter value and press Enter
+ *   F->>F: addFilter() - Step 3 completed
+ *   F->>F: Create complete filter object
+ *   F->>P: Emit filterEvent with new filter array
+ *   F->>F: Reset to step 1 for next filter
+ *
+ * @memberOf ForAngularModule
+ */
+let FilterComponent = class FilterComponent extends NgxBaseComponent {
+    /**
+     * @description Constructor for FilterComponent.
+     * @summary Initializes a new instance of the FilterComponent.
+     * Calls the parent constructor with the component name to establish base locale string generation
+     * and internationalization support.
+     *
+     * @memberOf FilterComponent
+     */
+    constructor() {
+        super("FilterComponent");
+        /**
+         * @description Available field indexes for filtering operations.
+         * @summary Defines the list of field names that users can filter by. These represent
+         * the data properties available for filtering operations. Each index corresponds to
+         * a field in the data model that supports comparison operations.
+         *
+         * @type {string[]}
+         * @default []
+         * @memberOf FilterComponent
+         */
+        this.indexes = [];
+        /**
+         * @description Available comparison conditions for filters.
+         * @summary Defines the list of comparison operators that can be used when creating filters.
+         * These conditions determine how the filter value is compared against the field value.
+         * Common conditions include equality, containment, and numerical comparison operations.
+         *
+         * @type {string[]}
+         * @default []
+         * @memberOf FilterComponent
+         */
+        this.conditions = ['Equal', 'Contains', 'Not Contains', 'Greater Than', 'Less Than', 'Not Equal'];
+        /**
+         * @description Available sorting options for the filtered data.
+         * @summary Defines the list of field names that can be used for sorting the filtered results.
+         * When disableSort is false, this array is automatically merged with the indexes array
+         * to provide comprehensive sorting capabilities.
+         *
+         * @type {string[]}
+         * @default []
+         * @memberOf FilterComponent
+         */
+        this.sortBy = [];
+        /**
+         * @description Controls whether sorting functionality is disabled.
+         * @summary When set to true, prevents the automatic merging of sort and indexes arrays,
+         * effectively disabling sorting capabilities. This is useful when you want to provide
+         * filtering without sorting options.
+         *
+         * @type {boolean}
+         * @default false
+         * @memberOf FilterComponent
+         */
+        this.disableSort = false;
+        /**
+         * @description Available options for the current filter step.
+         * @summary Contains the list of options available for selection in the current step.
+         * This array changes dynamically based on the current step: indexes → conditions → empty for value input.
+         *
+         * @type {string[]}
+         * @default []
+         * @memberOf FilterComponent
+         */
+        this.options = [];
+        /**
+         * @description Filtered options based on user input.
+         * @summary Contains the subset of options that match the current user input for real-time
+         * filtering. This array is updated as the user types to show only relevant suggestions
+         * in the dropdown menu.
+         *
+         * @type {string[]}
+         * @default []
+         * @memberOf FilterComponent
+         */
+        this.filteredOptions = [];
+        /**
+         * @description Complete filter objects created by the user.
+         * @summary Array of complete filter objects, each containing index, condition, and value properties.
+         * These represent the active filters that can be applied to data operations.
+         *
+         * @type {KeyValue[]}
+         * @default []
+         * @memberOf FilterComponent
+         */
+        this.filterValue = [];
+        /**
+         * @description Current filter being constructed.
+         * @summary Temporary object that accumulates filter properties (index, condition, value)
+         * during the three-step filter creation process. Gets added to filterValue when complete.
+         *
+         * @type {KeyValue}
+         * @default {}
+         * @memberOf FilterComponent
+         */
+        this.lastFilter = {};
+        /**
+         * @description Current step in the filter creation process.
+         * @summary Tracks the current step of filter creation: 1 = index selection, 2 = condition selection,
+         * 3 = value input. Automatically resets to 1 after completing a filter.
+         *
+         * @type {number}
+         * @default 1
+         * @memberOf FilterComponent
+         */
+        this.step = 1;
+        /**
+         * @description Controls dropdown visibility state.
+         * @summary Boolean flag that determines whether the options dropdown is currently visible.
+         * Used to manage the dropdown's open/close state and coordinate with focus/blur events.
+         *
+         * @type {boolean}
+         * @default false
+         * @memberOf FilterComponent
+         */
+        this.dropdownOpen = false;
+        /**
+         * @description Current input field value.
+         * @summary Stores the current text input value that the user is typing. This value is
+         * bound to the input field and is cleared after each successful filter step completion.
+         *
+         * @type {string}
+         * @default ''
+         * @memberOf FilterComponent
+         */
+        this.value = '';
+        /**
+         * @description Current sorting field value.
+         * @summary Stores the field name currently selected for sorting operations.
+         * This value determines which field is used to order the filtered results.
+         * Defaults to 'id' and can be changed through the sort dropdown selection.
+         *
+         * @type {string}
+         * @default 'id'
+         * @memberOf FilterComponent
+         */
+        this.sortValue = 'id';
+        /**
+         * @description Current sorting direction.
+         * @summary Defines the direction of the sort operation - ascending or descending.
+         * This value works in conjunction with sortValue to determine the complete
+         * sorting configuration for filtered results.
+         *
+         * @type {OrderDirection}
+         * @default OrderDirection.DSC
+         * @memberOf FilterComponent
+         */
+        this.sortDirection = OrderDirection.DSC;
+        /**
+         * @description Event emitter for filter changes.
+         * @summary Emits filter events when the user creates, modifies, or clears filters.
+         * The emitted value contains an array of complete filter objects or undefined when
+         * filters are cleared. Parent components listen to this event to update their data display.
+         *
+         * @type {EventEmitter<KeyValue[] | undefined>}
+         * @memberOf FilterComponent
+         */
+        this.filterEvent = new EventEmitter();
+        /**
+         * @description Event emitter for search events.
+         * @summary Emits search events when the user interacts with the searchbar.
+         * @type {EventEmitter<string>}
+         * @memberOf FilterComponent
+         */
+        this.searchEvent = new EventEmitter();
+        addIcons({ chevronDownOutline, chevronUpOutline });
+    }
+    /**
+     * @description Initializes the component after Angular first displays the data-bound properties.
+     * @summary Sets up the component by initializing window width tracking, setting up resize event
+     * subscriptions with debouncing, configuring sorting options, and calling the base initialization.
+     * This method prepares the component for user interaction and responsive behavior.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant A as Angular Lifecycle
+     *   participant F as FilterComponent
+     *   participant W as Window
+     *   participant R as RxJS
+     *
+     *   A->>F: ngOnInit()
+     *   F->>W: getWindowWidth()
+     *   W-->>F: Return current width
+     *   F->>R: Setup resize subscription with debounce
+     *   R-->>F: Subscription created
+     *   alt disableSort is false
+     *     F->>F: Merge sort and indexes arrays
+     *   end
+     *   F->>F: Call initialize()
+     *
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    ngOnInit() {
+        this.windowWidth = getWindowWidth();
+        this.windowResizeSubscription = fromEvent(window, 'resize')
+            .pipe(debounceTime(300))
+            .subscribe(() => {
+            this.windowWidth = getWindowWidth();
+        });
+        this.getIndexes();
+        this.initialize();
+    }
+    /**
+     * @description Retrieves and configures available indexes for filtering and sorting.
+     * @summary Extracts field indexes from the model if available and merges them with
+     * sorting options when sorting is enabled. This method sets up the available field
+     * options for both filtering and sorting operations based on the model structure.
+     *
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    getIndexes() {
+        if (this.model)
+            this.indexes = Object.keys(Repository.indexes(this.model) || {});
+        if (!this.disableSort)
+            this.sortBy = [...this.sortBy, ...this.indexes];
+    }
+    /**
+     * @description Cleanup method called when the component is destroyed.
+     * @summary Unsubscribes from window resize events to prevent memory leaks.
+     * This is essential for proper cleanup of RxJS subscriptions when the component
+     * is removed from the DOM.
+     *
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    ngOnDestroy() {
+        this.windowResizeSubscription.unsubscribe();
+        this.clear();
+    }
+    /**
+     * @description Handles input events from the text field.
+     * @summary Processes user input and filters the available options based on the typed value.
+     * This method provides real-time filtering of suggestions as the user types in the input field.
+     *
+     * @param {InputEvent} event - The input event containing the new value
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    handleInput(event) {
+        const { value } = event.target;
+        this.filteredOptions = this.filterOptions(value);
+    }
+    /**
+     * @description Handles focus events on the input field.
+     * @summary Sets up the available options when the input field receives focus and opens the dropdown.
+     * If no options are provided, automatically determines the appropriate options based on current step.
+     * This method initializes the dropdown with contextually relevant suggestions.
+     *
+     * @param {string[]} options - Optional array of options to display
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    handleFocus(options = []) {
+        if (!options.length)
+            options = this.getOptions();
+        this.filteredOptions = this.options = options;
+        this.dropdownOpen = true;
+    }
+    /**
+     * @description Handles blur events on the input field with delayed closing.
+     * @summary Manages the dropdown closing behavior with a delay to allow for option selection.
+     * Uses a two-phase approach to prevent premature closing when users click on dropdown options.
+     *
+     * @param {boolean} close - Internal flag to control the closing phase
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    handleBlur(close = false) {
+        if (!close) {
+            this.dropdownOpen = false;
+            setTimeout(() => {
+                this.handleBlur(true);
+            }, 100);
+        }
+        else {
+            if (!this.dropdownOpen && this.options.length) {
+                setTimeout(() => {
+                    this.options = [];
+                    this.dropdownOpen = false;
+                }, 50);
+            }
+        }
+    }
+    /**
+     * @description Determines the appropriate options based on the current filter step.
+     * @summary Returns the contextually relevant options for the current step in the filter creation process.
+     * Step 1 shows indexes, Step 2 shows conditions, Step 3 shows no options (value input).
+     *
+     * @returns {string[]} Array of options appropriate for the current step
+     * @memberOf FilterComponent
+     */
+    getOptions() {
+        switch (this.step) {
+            case 1:
+                this.options = this.indexes;
+                break;
+            case 2:
+                this.options = this.conditions;
+                break;
+            case 3:
+                this.options = [];
+                break;
+        }
+        return this.options;
+    }
+    /**
+     * @description Adds a filter step or completes filter creation through a three-step process.
+     * @summary Core method for building filters step by step: Step 1 (Index) → Step 2 (Condition) → Step 3 (Value).
+     * When all steps are complete, creates a complete filter object and adds it to the filter collection.
+     * Handles both keyboard events (Enter to submit) and programmatic calls.
+     *
+     * @param {string} value - The value to add for the current step
+     * @param {CustomEvent} event - Optional event (KeyboardEvent triggers submission when value is empty)
+     * @returns {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant F as FilterComponent
+     *
+     *   U->>F: addFilter(value, event)
+     *   F->>F: Trim and validate value
+     *   alt KeyboardEvent && empty value
+     *     F->>F: submit() - Send current filters
+     *   else Valid value or step 3
+     *     alt Step 1 (Index)
+     *       F->>F: lastFilter.index = value
+     *       F->>F: options = conditions
+     *     else Step 2 (Condition)
+     *       F->>F: lastFilter.condition = value
+     *       F->>F: options = []
+     *     else Step 3 (Value)
+     *       F->>F: lastFilter.value = value
+     *       F->>F: Add complete filter to filterValue
+     *       F->>F: Reset step to 1
+     *     end
+     *     F->>F: Increment step
+     *     F->>F: Clear input & focus
+     *     F->>F: Show next options
+     *   end
+     *
+     * @memberOf FilterComponent
+     */
+    addFilter(value, event) {
+        value = value.trim();
+        if (event instanceof KeyboardEvent && !value) {
+            this.submit();
+        }
+        else {
+            if ((value && (!(event instanceof KeyboardEvent)) || this.step === 3)) {
+                const filter = this.lastFilter;
+                switch (this.step) {
+                    case 1:
+                        filter['index'] = value;
+                        this.options = this.conditions;
+                        break;
+                    case 2:
+                        filter['condition'] = value;
+                        this.options = [];
+                        break;
+                    case 3:
+                        filter['value'] = value;
+                        this.options = this.indexes;
+                        break;
+                }
+                if (!this.filterValue.length) {
+                    this.filterValue.push(filter);
+                }
+                else {
+                    if (this.step === 1)
+                        this.filterValue.push(filter);
+                }
+                if (this.step === 3) {
+                    this.step = 0;
+                    this.filterValue[this.filterValue.length - 1] = filter;
+                    this.lastFilter = {};
+                }
+                this.step++;
+                this.value = '';
+                if (this.options.length)
+                    this.handleFocus(this.options);
+                this.component.nativeElement.focus();
+            }
+        }
+    }
+    /**
+     * @description Selects an option from the dropdown suggestions.
+     * @summary Handles option selection when a user clicks on a suggestion in the dropdown.
+     * This method acts as a bridge between dropdown clicks and the main addFilter logic.
+     *
+     * @param {CustomEvent} event - The click event from the dropdown option
+     * @param {string} value - The selected option value
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    selectOption(value) {
+        this.addFilter(value);
+    }
+    /**
+     * @description Determines if a filter option can be individually removed.
+     * @summary Checks whether a filter component should display a close icon for removal.
+     * Only value options can be removed individually; index and condition options are part
+     * of the complete filter structure and cannot be removed separately.
+     *
+     * @param {string} option - The filter option text to check
+     * @returns {boolean} True if the option can be cleared individually, false otherwise
+     * @memberOf FilterComponent
+     */
+    allowClear(option) {
+        return this.indexes.indexOf(option) === -1 && this.conditions.indexOf(option) === -1;
+    }
+    /**
+     * @description Removes a complete filter from the collection based on filter value.
+     * @summary Removes a complete filter by matching the provided value against filter values
+     * in the collection. Uses string normalization to handle accents and case differences.
+     * After removal, resets the interface to show available indexes for new filter creation.
+     *
+     * @param {string} filter - The filter value to remove (matches against filter.value property)
+     * @returns {void}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant F as FilterComponent
+     *
+     *   U->>F: removeFilter(filterValue)
+     *   F->>F: cleanString(filterValue)
+     *   F->>F: Filter out matching filter objects
+     *   F->>F: Clear input value
+     *   F->>F: handleFocus(indexes) - Reset to index selection
+     *   Note over F: Filter removed and UI reset
+     *
+     * @memberOf FilterComponent
+     */
+    removeFilter(filter) {
+        function cleanString(filter) {
+            return filter
+                .toLowerCase() // convert all characters to lowercase
+                .normalize("NFD") // separate accent marks from characters
+                .replace(/[\u0300-\u036f]/g, "") // remove accent marks
+                .replace(/\s+/g, ""); // remove all whitespace
+        }
+        this.value = "";
+        this.filterValue = this.filterValue.filter((item) => item?.['value'] && cleanString(item?.['value']) !== cleanString(filter));
+        if (this.filterValue.length === 0) {
+            this.step = 1;
+            this.lastFilter = {};
+        }
+        this.handleFocus(this.indexes);
+    }
+    /**
+     * @description Resets the component to its initial state.
+     * @summary Clears all filter data, options, and resets the step counter to 1.
+     * This method provides a clean slate for new filter creation without emitting events.
+     *
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    reset() {
+        this.options = this.filteredOptions = this.filterValue = [];
+        this.step = 1;
+        this.lastFilter = {};
+        this.value = '';
+        setTimeout(() => {
+            this.submit();
+        }, 100);
+    }
+    /**
+     * @description Clears all filters and notifies parent components.
+     * @summary Resets the component state and emits undefined to notify parent components
+     * that all filters have been cleared. This triggers any connected data refresh logic.
+     *
+     * @param {string} value - Optional parameter (currently unused)
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    clear(value) {
+        if (!value)
+            this.reset();
+    }
+    /**
+     * @description Submits the current filter collection to parent components.
+     * @summary Emits the current filter array to parent components when filters are ready
+     * to be applied. Only emits if there are active filters. Clears options after submission.
+     *
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    submit() {
+        this.filterEvent.emit({
+            query: this.filterValue.length > 0 ? this.filterValue : undefined,
+            sort: {
+                value: this.sortValue,
+                direction: this.sortDirection
+            }
+        });
+        if (this.filterValue.length === 0)
+            this.options = [];
+    }
+    /**
+     * @description Toggles the sort direction between ascending and descending.
+     * @summary Handles sort direction changes by toggling between ASC and DSC values.
+     * When the direction changes, automatically triggers a submit to apply the new
+     * sorting configuration to the filtered results.
+     *
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    handleSortDirectionChange() {
+        const direction = this.sortDirection === OrderDirection.ASC ? OrderDirection.DSC : OrderDirection.ASC;
+        if (direction !== this.sortDirection) {
+            this.sortDirection = direction;
+            this.submit();
+        }
+    }
+    /**
+     * @description Handles sort field selection changes from the dropdown.
+     * @summary Processes sort field changes when users select a different field
+     * from the sort dropdown. Updates the sortValue property and triggers
+     * a submit to apply the new sorting configuration if the value has changed.
+     *
+     * @param {CustomEvent} event - The select change event containing the new sort field value
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    handleSortChange(event) {
+        const target = event.target;
+        const value = target.value;
+        if (value !== this.sortValue) {
+            this.sortValue = value;
+            this.submit();
+        }
+    }
+    /**
+     * @description Filters available options based on user input with visual highlighting.
+     * @summary Performs real-time filtering of available options based on user input.
+     * Also handles visual highlighting of matching options in the dropdown. Returns all
+     * options if input is less than 2 characters for performance optimization.
+     *
+     * @param {string | null | undefined} value - The search value to filter by
+     * @returns {string[]} Array of filtered options that match the input
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant U as User
+     *   participant F as FilterComponent
+     *   participant D as DOM
+     *
+     *   U->>F: filterOptions(inputValue)
+     *   alt inputValue < 2 characters
+     *     F->>D: Remove existing highlights
+     *     F-->>U: Return all options
+     *   else inputValue >= 2 characters
+     *     F->>D: Query all option elements
+     *     F->>D: Add highlight to first matching option
+     *     F->>F: Filter options by substring match
+     *     F-->>U: Return filtered options
+     *   end
+     *
+     * @memberOf FilterComponent
+     */
+    filterOptions(value) {
+        const optionsElement = this.optionsFilterElement.nativeElement;
+        if (!value?.length || !value || value.length < 2) {
+            const filteredOption = optionsElement.querySelector('.dcf-filtering-item');
+            if (filteredOption)
+                filteredOption.classList.remove('dcf-filtering-item');
+            return this.options;
+        }
+        const options = optionsElement.querySelectorAll('.dcf-item');
+        for (const option of options) {
+            const isActive = option.textContent?.toLowerCase().includes(value.toLowerCase());
+            if (isActive) {
+                option.classList.add('dcf-filtering-item');
+                break;
+            }
+        }
+        return this.options.filter((option) => option.toLowerCase().includes(value.toLowerCase()));
+    }
+    /**
+     * @description Handles search events from the integrated searchbar component.
+     * @summary Processes search input from the searchbar and emits search events
+     * to parent components. This method acts as a bridge between the internal
+     * searchbar component and external search event listeners.
+     *
+     * @param {string | undefined} value - The search value entered by the user
+     * @returns {void}
+     * @memberOf FilterComponent
+     */
+    handleSearch(value) {
+        this.searchEvent.emit(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FilterComponent, isStandalone: true, selector: "ngx-decaf-filter", inputs: { indexes: "indexes", conditions: "conditions", sortBy: "sortBy", disableSort: "disableSort" }, outputs: { filterEvent: "filterEvent", searchEvent: "searchEvent" }, viewQueries: [{ propertyName: "optionsFilterElement", first: true, predicate: ["optionsFilterElement"], descendants: true, read: ElementRef }], usesInheritance: true, ngImport: i0, template: "\n@if(!indexes.length) {\n  <ngx-decaf-searchbar [emitEventToWindow]=\"false\" [debounce]=\"500\" (searchEvent)=\"handleSearch($event)\" />\n}\n\n<div class=\"dcf-grid dcf-grid-small dcf-grid-match dcf-filter-grid\" [ngClass]=\"{'dcf-hidden': !indexes.length}\">\n  <div class=\"dcf-width-expand\">\n    <div class=\"dcf-filter\">\n      <div class=\"dcf-input\">\n        @for(filter of filterValue; track trackItemFn($index, filter?.['index'])) {\n          @if(filter?.['index']) {\n            <ion-chip [outline]=\"true\">{{ filter?.['index'] }}</ion-chip>\n          }\n          @if(filter?.['condition']) {\n            <ion-chip [outline]=\"true\">{{ filter?.['condition'] }}</ion-chip>\n          }\n          @if(filter?.['value']) {\n            <ion-chip [outline]=\"true\" class=\"dcf-filter-value\">\n              {{ filter?.['value'] }}\n              <ion-icon name=\"close\" (click)=\"removeFilter(filter?.['value'])\" size=\"small\"></ion-icon>\n            </ion-chip>\n          }\n        }\n        <div class=\"dcf-width-1-1\">\n          <input\n            fill=\"none\"\n            [(ngModel)]=\"value\"\n            (keydown.enter)=\"addFilter(value, $event)\"\n            (keydown.backspace)=\"clear(value)\"\n            (input)=\"handleInput($event)\"\n            (click)=\"handleFocus()\"\n            (blur)=\"handleBlur()\"\n            type=\"text\"\n            [readonly]=\"step !== 3\"\n            placeholder=\"{{ locale + (step === 3 ? '.type' : '.select') | translate }}\"\n            #component\n          />\n          @if(windowWidth >= 768) {\n            <div [class]=\"'dcf-dropdown ' + (options.length > 0 ? ' dcf-active' : '')\" #optionsFilterElement>\n              <div>\n                @if(filteredOptions.length > 0) {\n                  @for(key of filteredOptions; track key) {\n                    <div\n                      class=\"dcf-item\"\n                      tabindex=\"0\"\n                      (keydown.enter)=\"selectOption(key)\"\n                      (click)=\"selectOption(key)\">\n                      {{ key }}\n                    </div>\n                  }\n                } @else {\n                  <div class=\"dcf-empty\"\n                    (click)=\"filteredOptions = options; value = ''\"\n                    tabindex=\"0\"\n                    (keydown.enter)=\"filteredOptions = options; value = ''\"\n                  >\n                    {{ 'no_suggestions' | translate }}\n                  </div>\n                }\n              </div>\n            </div>\n          }\n        </div>\n      </div>\n      @if(filterValue.length > 0) {\n        <div class=\"dcf-icon-clear\">\n          <ion-button fill=\"clear\" size=\"small\" (click)=\"clear()\">\n            <ion-icon name=\"trash-outline\" color=\"dark\" slot=\"icon-only\"></ion-icon>\n          </ion-button>\n        </div>\n      }\n      <div class=\"dcf-icon-search\">\n        <ion-button fill=\"clear\" size=\"small\" (click)=\"submit()\">\n          <ion-icon name=\"search-outline\" color=\"dark\" slot=\"icon-only\"></ion-icon>\n        </ion-button>\n      </div>\n    </div>\n    @if(windowWidth < 768) {\n      <div [class]=\"'dcf-dropdown ' + (options.length > 0 ? ' dcf-active' : '')\" #optionsFilterElement>\n        <div>\n          @if(filteredOptions.length > 0) {\n            @for(key of filteredOptions; track key) {\n              <div\n                class=\"dcf-item\"\n                tabindex=\"0\"\n                (keydown.enter)=\"selectOption(key)\"\n                (click)=\"selectOption(key)\">\n                {{ key }}\n              </div>\n            }\n          } @else {\n            <div class=\"dcf-empty\"\n            (click)=\"filteredOptions = options; value = ''\"\n            tabindex=\"0\"\n            (keydown.enter)=\"filteredOptions = options; value = ''\"\n            >\n              {{ 'no_suggestions' | translate }}\n            </div>\n          }\n        </div>\n      </div>\n    }\n  </div>\n  @if(!disableSort) {\n    <div class=\"dcf-width-1-5@m dcf-width-1-1 dcf-sort-container\">\n      <div class=\"dcf-grid dcf-grid-collapse dcf-flex dcf-flex-middle dcf-grid-match\">\n        <div class=\"dcf-width-expand\">\n          <ion-select\n              toggleIcon=\"chevron-down-outline\"\n              expandedIcon=\"chevron-up-outline\"\n              class=\"dcf-sort-select\"\n              (ionChange)=\"handleSortChange($event)\"\n              interface=\"popover\"\n              [value]=\"sortValue\"\n              label-placement=\"floating\"\n              fill=\"outline\"\n            >\n            @for(sort of sortBy; track sort) {\n              aa\n              <ion-select-option [value]=\"sort\">{{ sort | translate }}</ion-select-option>\n            }\n          </ion-select>\n        </div>\n        <div class=\"dcf-width-auto\">\n          <ion-button (click)=\"handleSortDirectionChange()\" fill=\"clear\">\n            <ion-icon slot=\"icon-only\" [name]=\"sortDirection === 'desc' ? 'arrow-down-outline' : 'arrow-up-outline'\"></ion-icon>\n          </ion-button>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n\n\n", styles: [".dcf-filter-grid{padding:0 .5rem;margin-top:.75rem;margin-bottom:.75rem}ion-select{min-height:44px!important}.dcf-hidden{display:none!important}.dcf-filter{display:flex;width:100%;min-height:40px;border:1px solid var(--ion-color-gray-3);box-shadow:0 1px 2px #0a0d120d;background-color:#fff;border-radius:var(--dcf-border-radius);box-sizing:border-box}.dcf-filter:focus-within{border-color:var(--ion-color-primary);background-color:#fff}.dcf-filter ion-chip{border-radius:6px;padding:0 8px!important;height:24px;min-height:24px;font-size:.75rem;border:1px solid var(--ion-color-gray-3);color:var(--ion-color-gray-7);font-style:normal;font-weight:500;flex-shrink:0;margin-right:2px;white-space:nowrap}.dcf-filter ion-chip.dcf-filter-value{background:var(--ion-color-gray-2);border-color:var(--ion-color-gray-4)!important;color:var(--ion-color-gray-8)!important}.dcf-filter ion-chip.sc-ion-chip-md-h,.dcf-filter ion-chip.sc-ion-chip-ios-h{height:24px;min-height:24px}.dcf-filter ion-chip.sc-ion-chip-md-h .chip-native,.dcf-filter ion-chip.sc-ion-chip-ios-h .chip-native{padding:0 8px!important;height:24px;min-height:24px}.dcf-filter ion-chip ion-label{padding:0 4px;margin:0;font-size:.75rem;white-space:nowrap}.dcf-filter ion-chip ion-icon{margin:0 2px;font-size:.75rem}.dcf-filter .dcf-input{width:100%;display:flex;align-items:center;overflow-x:auto;overflow-y:hidden;white-space:nowrap;padding-left:.5rem}.dcf-filter .dcf-input input{min-height:40px;color:var(--ion-color-gray-7);min-width:100px;width:100%;font-size:1rem;border:none;outline:none;background:transparent;border:0px!important;outline:none!important}.dcf-filter .dcf-input input:focus{border:0px!important;outline:none!important}.dcf-filter .dcf-icon-clear,.dcf-filter .dcf-icon-search{display:flex;justify-content:center;text-align:center;align-items:center;min-width:40px}.dcf-filter .dcf-icon-search ion-icon{font-size:1.25rem}.dcf-sort-container{min-width:200px!important;width:auto}@media (min-width: 990px){.dcf-sort-container{max-width:20%!important}}@media (max-width: 680px){.dcf-sort-container{min-width:100%!important;margin:.75rem 0rem}}.dcf-dropdown{position:absolute;max-height:200px;overflow-y:auto;background-color:#fff;border-radius:4px;z-index:1000!important;min-width:200px;max-width:300px;display:none}.dcf-dropdown.dcf-active{display:block;margin-top:-3px;box-shadow:0 12px 16px -4px #0a0d1214,0 4px 6px -2px #0a0d1208,0 2px 2px -1px #0a0d120a!important;border:1px solid var(--ion-color-gray-2);border-radius:var(--dcf-border-radius);padding:.5rem .25rem}@media (max-width: 768px){.dcf-dropdown.dcf-active{margin-top:55px}}.dcf-dropdown.dcf-active>div>div{cursor:pointer;height:35px;padding:.5rem 1rem;border:1px solid transparent;font-size:1rem;display:flex;align-items:center;color:var(--ion-color-gray-8);border-radius:6px}.dcf-dropdown.dcf-active>div>div.dcf-filtering-item,.dcf-dropdown.dcf-active>div>div:only-child{border-color:var(--ion-color-primary)}.dcf-dropdown.dcf-active>div>div.dcf-filtering-item.dcf-empty,.dcf-dropdown.dcf-active>div>div:only-child.dcf-empty{border-color:var(--ion-color-gray-7)!important}.dcf-dropdown.dcf-active>div>div:hover{background-color:var(--ion-color-gray-1)}\n"], dependencies: [{ kind: "ngmodule", type: ForAngularModule }, { kind: "component", type: i1.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }, { kind: "component", type: IonChip, selector: "ion-chip", inputs: ["color", "disabled", "mode", "outline"] }, { kind: "component", type: IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: IonSelect, selector: "ion-select", inputs: ["cancelText", "color", "compareWith", "disabled", "errorText", "expandedIcon", "fill", "helperText", "interface", "interfaceOptions", "justify", "label", "labelPlacement", "mode", "multiple", "name", "okText", "placeholder", "selectedText", "shape", "toggleIcon", "value"] }, { 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"] }] }); }
+};
+FilterComponent = __decorate([
+    Dynamic(),
+    __metadata("design:paramtypes", [])
+], FilterComponent);
+export { FilterComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-decaf-filter', imports: [
+                        ForAngularModule,
+                        IonLabel,
+                        IonItem,
+                        IonChip,
+                        IonIcon,
+                        IonSelect,
+                        IonIcon,
+                        SearchbarComponent
+                    ], standalone: true, template: "\n@if(!indexes.length) {\n  <ngx-decaf-searchbar [emitEventToWindow]=\"false\" [debounce]=\"500\" (searchEvent)=\"handleSearch($event)\" />\n}\n\n<div class=\"dcf-grid dcf-grid-small dcf-grid-match dcf-filter-grid\" [ngClass]=\"{'dcf-hidden': !indexes.length}\">\n  <div class=\"dcf-width-expand\">\n    <div class=\"dcf-filter\">\n      <div class=\"dcf-input\">\n        @for(filter of filterValue; track trackItemFn($index, filter?.['index'])) {\n          @if(filter?.['index']) {\n            <ion-chip [outline]=\"true\">{{ filter?.['index'] }}</ion-chip>\n          }\n          @if(filter?.['condition']) {\n            <ion-chip [outline]=\"true\">{{ filter?.['condition'] }}</ion-chip>\n          }\n          @if(filter?.['value']) {\n            <ion-chip [outline]=\"true\" class=\"dcf-filter-value\">\n              {{ filter?.['value'] }}\n              <ion-icon name=\"close\" (click)=\"removeFilter(filter?.['value'])\" size=\"small\"></ion-icon>\n            </ion-chip>\n          }\n        }\n        <div class=\"dcf-width-1-1\">\n          <input\n            fill=\"none\"\n            [(ngModel)]=\"value\"\n            (keydown.enter)=\"addFilter(value, $event)\"\n            (keydown.backspace)=\"clear(value)\"\n            (input)=\"handleInput($event)\"\n            (click)=\"handleFocus()\"\n            (blur)=\"handleBlur()\"\n            type=\"text\"\n            [readonly]=\"step !== 3\"\n            placeholder=\"{{ locale + (step === 3 ? '.type' : '.select') | translate }}\"\n            #component\n          />\n          @if(windowWidth >= 768) {\n            <div [class]=\"'dcf-dropdown ' + (options.length > 0 ? ' dcf-active' : '')\" #optionsFilterElement>\n              <div>\n                @if(filteredOptions.length > 0) {\n                  @for(key of filteredOptions; track key) {\n                    <div\n                      class=\"dcf-item\"\n                      tabindex=\"0\"\n                      (keydown.enter)=\"selectOption(key)\"\n                      (click)=\"selectOption(key)\">\n                      {{ key }}\n                    </div>\n                  }\n                } @else {\n                  <div class=\"dcf-empty\"\n                    (click)=\"filteredOptions = options; value = ''\"\n                    tabindex=\"0\"\n                    (keydown.enter)=\"filteredOptions = options; value = ''\"\n                  >\n                    {{ 'no_suggestions' | translate }}\n                  </div>\n                }\n              </div>\n            </div>\n          }\n        </div>\n      </div>\n      @if(filterValue.length > 0) {\n        <div class=\"dcf-icon-clear\">\n          <ion-button fill=\"clear\" size=\"small\" (click)=\"clear()\">\n            <ion-icon name=\"trash-outline\" color=\"dark\" slot=\"icon-only\"></ion-icon>\n          </ion-button>\n        </div>\n      }\n      <div class=\"dcf-icon-search\">\n        <ion-button fill=\"clear\" size=\"small\" (click)=\"submit()\">\n          <ion-icon name=\"search-outline\" color=\"dark\" slot=\"icon-only\"></ion-icon>\n        </ion-button>\n      </div>\n    </div>\n    @if(windowWidth < 768) {\n      <div [class]=\"'dcf-dropdown ' + (options.length > 0 ? ' dcf-active' : '')\" #optionsFilterElement>\n        <div>\n          @if(filteredOptions.length > 0) {\n            @for(key of filteredOptions; track key) {\n              <div\n                class=\"dcf-item\"\n                tabindex=\"0\"\n                (keydown.enter)=\"selectOption(key)\"\n                (click)=\"selectOption(key)\">\n                {{ key }}\n              </div>\n            }\n          } @else {\n            <div class=\"dcf-empty\"\n            (click)=\"filteredOptions = options; value = ''\"\n            tabindex=\"0\"\n            (keydown.enter)=\"filteredOptions = options; value = ''\"\n            >\n              {{ 'no_suggestions' | translate }}\n            </div>\n          }\n        </div>\n      </div>\n    }\n  </div>\n  @if(!disableSort) {\n    <div class=\"dcf-width-1-5@m dcf-width-1-1 dcf-sort-container\">\n      <div class=\"dcf-grid dcf-grid-collapse dcf-flex dcf-flex-middle dcf-grid-match\">\n        <div class=\"dcf-width-expand\">\n          <ion-select\n              toggleIcon=\"chevron-down-outline\"\n              expandedIcon=\"chevron-up-outline\"\n              class=\"dcf-sort-select\"\n              (ionChange)=\"handleSortChange($event)\"\n              interface=\"popover\"\n              [value]=\"sortValue\"\n              label-placement=\"floating\"\n              fill=\"outline\"\n            >\n            @for(sort of sortBy; track sort) {\n              aa\n              <ion-select-option [value]=\"sort\">{{ sort | translate }}</ion-select-option>\n            }\n          </ion-select>\n        </div>\n        <div class=\"dcf-width-auto\">\n          <ion-button (click)=\"handleSortDirectionChange()\" fill=\"clear\">\n            <ion-icon slot=\"icon-only\" [name]=\"sortDirection === 'desc' ? 'arrow-down-outline' : 'arrow-up-outline'\"></ion-icon>\n          </ion-button>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n\n\n", styles: [".dcf-filter-grid{padding:0 .5rem;margin-top:.75rem;margin-bottom:.75rem}ion-select{min-height:44px!important}.dcf-hidden{display:none!important}.dcf-filter{display:flex;width:100%;min-height:40px;border:1px solid var(--ion-color-gray-3);box-shadow:0 1px 2px #0a0d120d;background-color:#fff;border-radius:var(--dcf-border-radius);box-sizing:border-box}.dcf-filter:focus-within{border-color:var(--ion-color-primary);background-color:#fff}.dcf-filter ion-chip{border-radius:6px;padding:0 8px!important;height:24px;min-height:24px;font-size:.75rem;border:1px solid var(--ion-color-gray-3);color:var(--ion-color-gray-7);font-style:normal;font-weight:500;flex-shrink:0;margin-right:2px;white-space:nowrap}.dcf-filter ion-chip.dcf-filter-value{background:var(--ion-color-gray-2);border-color:var(--ion-color-gray-4)!important;color:var(--ion-color-gray-8)!important}.dcf-filter ion-chip.sc-ion-chip-md-h,.dcf-filter ion-chip.sc-ion-chip-ios-h{height:24px;min-height:24px}.dcf-filter ion-chip.sc-ion-chip-md-h .chip-native,.dcf-filter ion-chip.sc-ion-chip-ios-h .chip-native{padding:0 8px!important;height:24px;min-height:24px}.dcf-filter ion-chip ion-label{padding:0 4px;margin:0;font-size:.75rem;white-space:nowrap}.dcf-filter ion-chip ion-icon{margin:0 2px;font-size:.75rem}.dcf-filter .dcf-input{width:100%;display:flex;align-items:center;overflow-x:auto;overflow-y:hidden;white-space:nowrap;padding-left:.5rem}.dcf-filter .dcf-input input{min-height:40px;color:var(--ion-color-gray-7);min-width:100px;width:100%;font-size:1rem;border:none;outline:none;background:transparent;border:0px!important;outline:none!important}.dcf-filter .dcf-input input:focus{border:0px!important;outline:none!important}.dcf-filter .dcf-icon-clear,.dcf-filter .dcf-icon-search{display:flex;justify-content:center;text-align:center;align-items:center;min-width:40px}.dcf-filter .dcf-icon-search ion-icon{font-size:1.25rem}.dcf-sort-container{min-width:200px!important;width:auto}@media (min-width: 990px){.dcf-sort-container{max-width:20%!important}}@media (max-width: 680px){.dcf-sort-container{min-width:100%!important;margin:.75rem 0rem}}.dcf-dropdown{position:absolute;max-height:200px;overflow-y:auto;background-color:#fff;border-radius:4px;z-index:1000!important;min-width:200px;max-width:300px;display:none}.dcf-dropdown.dcf-active{display:block;margin-top:-3px;box-shadow:0 12px 16px -4px #0a0d1214,0 4px 6px -2px #0a0d1208,0 2px 2px -1px #0a0d120a!important;border:1px solid var(--ion-color-gray-2);border-radius:var(--dcf-border-radius);padding:.5rem .25rem}@media (max-width: 768px){.dcf-dropdown.dcf-active{margin-top:55px}}.dcf-dropdown.dcf-active>div>div{cursor:pointer;height:35px;padding:.5rem 1rem;border:1px solid transparent;font-size:1rem;display:flex;align-items:center;color:var(--ion-color-gray-8);border-radius:6px}.dcf-dropdown.dcf-active>div>div.dcf-filtering-item,.dcf-dropdown.dcf-active>div>div:only-child{border-color:var(--ion-color-primary)}.dcf-dropdown.dcf-active>div>div.dcf-filtering-item.dcf-empty,.dcf-dropdown.dcf-active>div>div:only-child.dcf-empty{border-color:var(--ion-color-gray-7)!important}.dcf-dropdown.dcf-active>div>div:hover{background-color:var(--ion-color-gray-1)}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { optionsFilterElement: [{
+                type: ViewChild,
+                args: ['optionsFilterElement', { read: ElementRef, static: false }]
+            }], indexes: [{
+                type: Input
+            }], conditions: [{
+                type: Input
+            }], sortBy: [{
+                type: Input
+            }], disableSort: [{
+                type: Input
+            }], filterEvent: [{
+                type: Output
+            }], searchEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/filter/filter.component.ts","../../../../../src/lib/components/filter/filter.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, OnDestroy, OnInit, Output, ViewChild  } from '@angular/core';\nimport { ForAngularModule } from '../../for-angular.module';\nimport { NgxBaseComponent } from '../../engine/NgxBaseComponent';\nimport { IonChip, IonIcon, IonItem, IonLabel, IonSelect} from '@ionic/angular/standalone';\nimport { Dynamic, IFilterQuery, IFilterQueryItem } from '../../engine';\nimport { getWindowWidth } from '../../helpers/utils';\nimport { debounceTime, fromEvent, Subscription } from 'rxjs';\nimport { OrderDirection, Repository } from '@decaf-ts/core';\nimport { Model } from '@decaf-ts/decorator-validation';\nimport { SearchbarComponent } from '../searchbar/searchbar.component';\nimport { addIcons } from 'ionicons';\nimport { chevronDownOutline, chevronUpOutline } from 'ionicons/icons';\n\n/**\n * @description Advanced filter component for creating dynamic search filters with step-by-step construction.\n * @summary This component provides a comprehensive filtering interface that allows users to build\n * complex search criteria using a three-step approach: select index → select condition → enter value.\n * It supports filtering by multiple field indexes, comparison conditions, and values, displaying\n * selected filters as removable chips. The component is responsive and includes auto-suggestions\n * with keyboard navigation support.\n *\n * @example\n * ```html\n * <ngx-decaf-filter\n *   [indexes]=\"['name', 'email', 'department', 'status']\"\n *   [conditions]=\"['Equal', 'Contains', 'Greater Than', 'Less Than']\"\n *   [sort]=\"['createdAt', 'updatedAt']\"\n *   [disableSort]=\"false\"\n *   (filterEvent)=\"onFiltersChanged($event)\">\n * </ngx-decaf-filter>\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant U as User\n *   participant F as FilterComponent\n *   participant P as Parent Component\n *\n *   U->>F: Focus input field\n *   F->>F: handleFocus() - Show available indexes\n *   U->>F: Select index (e.g., \"name\")\n *   F->>F: addFilter() - Step 1 completed\n *   F->>F: Show available conditions\n *   U->>F: Select condition (e.g., \"Contains\")\n *   F->>F: addFilter() - Step 2 completed\n *   F->>F: Show value input prompt\n *   U->>F: Enter value and press Enter\n *   F->>F: addFilter() - Step 3 completed\n *   F->>F: Create complete filter object\n *   F->>P: Emit filterEvent with new filter array\n *   F->>F: Reset to step 1 for next filter\n *\n * @memberOf ForAngularModule\n */\n@Dynamic()\n@Component({\n  selector: 'ngx-decaf-filter',\n  templateUrl: './filter.component.html',\n  styleUrls: ['./filter.component.scss'],\n  imports: [\n    ForAngularModule,\n    IonLabel,\n    IonItem,\n    IonChip,\n    IonIcon,\n    IonSelect,\n    IonIcon,\n    SearchbarComponent\n  ],\n  standalone: true,\n})\nexport class FilterComponent extends NgxBaseComponent implements OnInit, OnDestroy {\n\n  /**\n   * @description Reference to the dropdown options container element.\n   * @summary ViewChild reference used to access and manipulate the dropdown options element\n   * for highlighting filtered items and managing visual feedback during option selection.\n   * This element contains the filterable suggestions that users can interact with.\n   *\n   * @type {ElementRef}\n   * @memberOf FilterComponent\n   */\n  @ViewChild('optionsFilterElement', { read: ElementRef, static: false })\n  optionsFilterElement!: ElementRef;\n\n  /**\n   * @description Available field indexes for filtering operations.\n   * @summary Defines the list of field names that users can filter by. These represent\n   * the data properties available for filtering operations. Each index corresponds to\n   * a field in the data model that supports comparison operations.\n   *\n   * @type {string[]}\n   * @default []\n   * @memberOf FilterComponent\n   */\n  @Input()\n  indexes: string[] = [];\n\n  /**\n   * @description Available comparison conditions for filters.\n   * @summary Defines the list of comparison operators that can be used when creating filters.\n   * These conditions determine how the filter value is compared against the field value.\n   * Common conditions include equality, containment, and numerical comparison operations.\n   *\n   * @type {string[]}\n   * @default []\n   * @memberOf FilterComponent\n   */\n  @Input()\n  conditions: string[] = ['Equal', 'Contains', 'Not Contains', 'Greater Than', 'Less Than', 'Not Equal'];\n\n  /**\n   * @description Available sorting options for the filtered data.\n   * @summary Defines the list of field names that can be used for sorting the filtered results.\n   * When disableSort is false, this array is automatically merged with the indexes array\n   * to provide comprehensive sorting capabilities.\n   *\n   * @type {string[]}\n   * @default []\n   * @memberOf FilterComponent\n   */\n  @Input()\n  sortBy: string[] = [];\n\n  /**\n   * @description Controls whether sorting functionality is disabled.\n   * @summary When set to true, prevents the automatic merging of sort and indexes arrays,\n   * effectively disabling sorting capabilities. This is useful when you want to provide\n   * filtering without sorting options.\n   *\n   * @type {boolean}\n   * @default false\n   * @memberOf FilterComponent\n   */\n  @Input()\n  disableSort: boolean = false;\n\n  /**\n   * @description Current window width for responsive behavior.\n   * @summary Stores the current browser window width in pixels. This value is updated\n   * on window resize events to enable responsive filtering behavior and layout adjustments\n   * based on available screen space.\n   *\n   * @type {number}\n   * @memberOf FilterComponent\n   */\n  windowWidth!: number;\n\n  /**\n   * @description Available options for the current filter step.\n   * @summary Contains the list of options available for selection in the current step.\n   * This array changes dynamically based on the current step: indexes → conditions → empty for value input.\n   *\n   * @type {string[]}\n   * @default []\n   * @memberOf FilterComponent\n   */\n  options: string[] = [];\n\n  /**\n   * @description Filtered options based on user input.\n   * @summary Contains the subset of options that match the current user input for real-time\n   * filtering. This array is updated as the user types to show only relevant suggestions\n   * in the dropdown menu.\n   *\n   * @type {string[]}\n   * @default []\n   * @memberOf FilterComponent\n   */\n  filteredOptions: string[] = [];\n\n  /**\n   * @description Complete filter objects created by the user.\n   * @summary Array of complete filter objects, each containing index, condition, and value properties.\n   * These represent the active filters that can be applied to data operations.\n   *\n   * @type {KeyValue[]}\n   * @default []\n   * @memberOf FilterComponent\n   */\n  filterValue: IFilterQueryItem[] = [];\n\n  /**\n   * @description Current filter being constructed.\n   * @summary Temporary object that accumulates filter properties (index, condition, value)\n   * during the three-step filter creation process. Gets added to filterValue when complete.\n   *\n   * @type {KeyValue}\n   * @default {}\n   * @memberOf FilterComponent\n   */\n  lastFilter: IFilterQueryItem = {};\n\n  /**\n   * @description Current step in the filter creation process.\n   * @summary Tracks the current step of filter creation: 1 = index selection, 2 = condition selection,\n   * 3 = value input. Automatically resets to 1 after completing a filter.\n   *\n   * @type {number}\n   * @default 1\n   * @memberOf FilterComponent\n   */\n  step: number = 1;\n\n  /**\n   * @description Controls dropdown visibility state.\n   * @summary Boolean flag that determines whether the options dropdown is currently visible.\n   * Used to manage the dropdown's open/close state and coordinate with focus/blur events.\n   *\n   * @type {boolean}\n   * @default false\n   * @memberOf FilterComponent\n   */\n  dropdownOpen: boolean = false;\n\n  /**\n   * @description Current input field value.\n   * @summary Stores the current text input value that the user is typing. This value is\n   * bound to the input field and is cleared after each successful filter step completion.\n   *\n   * @type {string}\n   * @default ''\n   * @memberOf FilterComponent\n   */\n  value: string = '';\n\n  /**\n   * @description Current sorting field value.\n   * @summary Stores the field name currently selected for sorting operations.\n   * This value determines which field is used to order the filtered results.\n   * Defaults to 'id' and can be changed through the sort dropdown selection.\n   *\n   * @type {string}\n   * @default 'id'\n   * @memberOf FilterComponent\n   */\n  sortValue: string = 'id';\n\n  /**\n   * @description Current sorting direction.\n   * @summary Defines the direction of the sort operation - ascending or descending.\n   * This value works in conjunction with sortValue to determine the complete\n   * sorting configuration for filtered results.\n   *\n   * @type {OrderDirection}\n   * @default OrderDirection.DSC\n   * @memberOf FilterComponent\n   */\n  sortDirection: OrderDirection = OrderDirection.DSC;\n\n  /**\n   * @description Subscription for window resize events.\n   * @summary RxJS subscription that listens for window resize events with debouncing\n   * to update the windowWidth property. This enables responsive behavior and prevents\n   * excessive updates during resize operations.\n   *\n   * @type {Subscription}\n   * @memberOf FilterComponent\n   */\n  windowResizeSubscription!: Subscription;\n\n  /**\n   * @description Event emitter for filter changes.\n   * @summary Emits filter events when the user creates, modifies, or clears filters.\n   * The emitted value contains an array of complete filter objects or undefined when\n   * filters are cleared. Parent components listen to this event to update their data display.\n   *\n   * @type {EventEmitter<KeyValue[] | undefined>}\n   * @memberOf FilterComponent\n   */\n  @Output()\n  filterEvent: EventEmitter<IFilterQuery | undefined> = new EventEmitter<IFilterQuery | undefined>();\n\n  /**\n   * @description Event emitter for search events.\n   * @summary Emits search events when the user interacts with the searchbar.\n   * @type {EventEmitter<string>}\n   * @memberOf FilterComponent\n   */\n  @Output()\n  searchEvent: EventEmitter<string> = new EventEmitter<string>();\n\n\n  /**\n   * @description Constructor for FilterComponent.\n   * @summary Initializes a new instance of the FilterComponent.\n   * Calls the parent constructor with the component name to establish base locale string generation\n   * and internationalization support.\n   *\n   * @memberOf FilterComponent\n   */\n  constructor() {\n    super(\"FilterComponent\");\n    addIcons({chevronDownOutline, chevronUpOutline});\n  }\n\n  /**\n   * @description Initializes the component after Angular first displays the data-bound properties.\n   * @summary Sets up the component by initializing window width tracking, setting up resize event\n   * subscriptions with debouncing, configuring sorting options, and calling the base initialization.\n   * This method prepares the component for user interaction and responsive behavior.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant A as Angular Lifecycle\n   *   participant F as FilterComponent\n   *   participant W as Window\n   *   participant R as RxJS\n   *\n   *   A->>F: ngOnInit()\n   *   F->>W: getWindowWidth()\n   *   W-->>F: Return current width\n   *   F->>R: Setup resize subscription with debounce\n   *   R-->>F: Subscription created\n   *   alt disableSort is false\n   *     F->>F: Merge sort and indexes arrays\n   *   end\n   *   F->>F: Call initialize()\n   *\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  ngOnInit(): void {\n    this.windowWidth = getWindowWidth() as number;\n    this.windowResizeSubscription = fromEvent(window, 'resize')\n    .pipe(debounceTime(300))\n    .subscribe(() => {\n     this.windowWidth = getWindowWidth() as number;\n    });\n\n    this.getIndexes();\n    this.initialize();\n  }\n\n  /**\n   * @description Retrieves and configures available indexes for filtering and sorting.\n   * @summary Extracts field indexes from the model if available and merges them with\n   * sorting options when sorting is enabled. This method sets up the available field\n   * options for both filtering and sorting operations based on the model structure.\n   *\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  getIndexes(): void {\n    if(this.model)\n      this.indexes = Object.keys(Repository.indexes(this.model as Model) || {});\n    if(!this.disableSort)\n      this.sortBy = [... this.sortBy, ...this.indexes];\n  }\n\n\n  /**\n   * @description Cleanup method called when the component is destroyed.\n   * @summary Unsubscribes from window resize events to prevent memory leaks.\n   * This is essential for proper cleanup of RxJS subscriptions when the component\n   * is removed from the DOM.\n   *\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  ngOnDestroy(): void {\n    this.windowResizeSubscription.unsubscribe();\n    this.clear();\n  }\n\n  /**\n   * @description Handles input events from the text field.\n   * @summary Processes user input and filters the available options based on the typed value.\n   * This method provides real-time filtering of suggestions as the user types in the input field.\n   *\n   * @param {InputEvent} event - The input event containing the new value\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  handleInput(event: InputEvent): void {\n    const {value} = event.target as HTMLInputElement;\n      this.filteredOptions = this.filterOptions(value);\n  }\n\n  /**\n   * @description Handles focus events on the input field.\n   * @summary Sets up the available options when the input field receives focus and opens the dropdown.\n   * If no options are provided, automatically determines the appropriate options based on current step.\n   * This method initializes the dropdown with contextually relevant suggestions.\n   *\n   * @param {string[]} options - Optional array of options to display\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  handleFocus(options: string[]  = []): void {\n    if(!options.length)\n     options = this.getOptions();\n    this.filteredOptions = this.options = options;\n    this.dropdownOpen = true;\n  }\n\n  /**\n   * @description Handles blur events on the input field with delayed closing.\n   * @summary Manages the dropdown closing behavior with a delay to allow for option selection.\n   * Uses a two-phase approach to prevent premature closing when users click on dropdown options.\n   *\n   * @param {boolean} close - Internal flag to control the closing phase\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  handleBlur(close: boolean = false): void {\n    if(!close) {\n      this.dropdownOpen = false;\n      setTimeout(() => {\n        this.handleBlur(true);\n      }, 100);\n    } else {\n      if(!this.dropdownOpen && this.options.length) {\n        setTimeout(() => {\n          this.options = [];\n          this.dropdownOpen = false;\n        }, 50);\n      }\n    }\n  }\n\n  /**\n   * @description Determines the appropriate options based on the current filter step.\n   * @summary Returns the contextually relevant options for the current step in the filter creation process.\n   * Step 1 shows indexes, Step 2 shows conditions, Step 3 shows no options (value input).\n   *\n   * @returns {string[]} Array of options appropriate for the current step\n   * @memberOf FilterComponent\n   */\n  getOptions(): string[] {\n   switch (this.step) {\n      case 1:\n        this.options = this.indexes;\n        break;\n      case 2:\n        this.options = this.conditions;\n        break;\n      case 3:\n        this.options = [];\n        break;\n    }\n    return this.options\n  }\n\n  /**\n   * @description Adds a filter step or completes filter creation through a three-step process.\n   * @summary Core method for building filters step by step: Step 1 (Index) → Step 2 (Condition) → Step 3 (Value).\n   * When all steps are complete, creates a complete filter object and adds it to the filter collection.\n   * Handles both keyboard events (Enter to submit) and programmatic calls.\n   *\n   * @param {string} value - The value to add for the current step\n   * @param {CustomEvent} event - Optional event (KeyboardEvent triggers submission when value is empty)\n   * @returns {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant F as FilterComponent\n   *\n   *   U->>F: addFilter(value, event)\n   *   F->>F: Trim and validate value\n   *   alt KeyboardEvent && empty value\n   *     F->>F: submit() - Send current filters\n   *   else Valid value or step 3\n   *     alt Step 1 (Index)\n   *       F->>F: lastFilter.index = value\n   *       F->>F: options = conditions\n   *     else Step 2 (Condition)\n   *       F->>F: lastFilter.condition = value\n   *       F->>F: options = []\n   *     else Step 3 (Value)\n   *       F->>F: lastFilter.value = value\n   *       F->>F: Add complete filter to filterValue\n   *       F->>F: Reset step to 1\n   *     end\n   *     F->>F: Increment step\n   *     F->>F: Clear input & focus\n   *     F->>F: Show next options\n   *   end\n   *\n   * @memberOf FilterComponent\n   */\n  addFilter(value: string, event?: CustomEvent): void {\n    value = value.trim();\n    if(event instanceof KeyboardEvent && !value) {\n      this.submit();\n    } else {\n       if((value && (!(event instanceof KeyboardEvent)) || this.step === 3)) {\n        const filter = this.lastFilter;\n        switch (this.step) {\n          case 1:\n            filter['index'] = value;\n            this.options = this.conditions;\n            break;\n          case 2:\n            filter['condition'] = value;\n            this.options = [];\n            break;\n          case 3:\n            filter['value'] = value;\n            this.options = this.indexes;\n            break;\n        }\n        if(!this.filterValue.length) {\n          this.filterValue.push(filter);\n        } else {\n          if(this.step === 1)\n            this.filterValue.push(filter);\n        }\n        if(this.step === 3) {\n          this.step = 0;\n          this.filterValue[this.filterValue.length - 1] = filter;\n          this.lastFilter = {};\n        }\n        this.step++;\n        this.value = '';\n        if(this.options.length)\n          this.handleFocus(this.options);\n        this.component.nativeElement.focus();\n      }\n    }\n  }\n\n  /**\n   * @description Selects an option from the dropdown suggestions.\n   * @summary Handles option selection when a user clicks on a suggestion in the dropdown.\n   * This method acts as a bridge between dropdown clicks and the main addFilter logic.\n   *\n   * @param {CustomEvent} event - The click event from the dropdown option\n   * @param {string} value - The selected option value\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  selectOption(value: string): void {\n    this.addFilter(value);\n  }\n\n  /**\n   * @description Determines if a filter option can be individually removed.\n   * @summary Checks whether a filter component should display a close icon for removal.\n   * Only value options can be removed individually; index and condition options are part\n   * of the complete filter structure and cannot be removed separately.\n   *\n   * @param {string} option - The filter option text to check\n   * @returns {boolean} True if the option can be cleared individually, false otherwise\n   * @memberOf FilterComponent\n   */\n  allowClear(option: string): boolean {\n    return this.indexes.indexOf(option) === -1 && this.conditions.indexOf(option) === -1;\n  }\n\n  /**\n   * @description Removes a complete filter from the collection based on filter value.\n   * @summary Removes a complete filter by matching the provided value against filter values\n   * in the collection. Uses string normalization to handle accents and case differences.\n   * After removal, resets the interface to show available indexes for new filter creation.\n   *\n   * @param {string} filter - The filter value to remove (matches against filter.value property)\n   * @returns {void}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant F as FilterComponent\n   *\n   *   U->>F: removeFilter(filterValue)\n   *   F->>F: cleanString(filterValue)\n   *   F->>F: Filter out matching filter objects\n   *   F->>F: Clear input value\n   *   F->>F: handleFocus(indexes) - Reset to index selection\n   *   Note over F: Filter removed and UI reset\n   *\n   * @memberOf FilterComponent\n   */\n  removeFilter(filter: string): void {\n    function cleanString(filter: string): string {\n      return filter\n        .toLowerCase()                 // convert all characters to lowercase\n        .normalize(\"NFD\")              // separate accent marks from characters\n        .replace(/[\\u0300-\\u036f]/g, \"\") // remove accent marks\n        .replace(/\\s+/g, \"\");          // remove all whitespace\n    }\n    this.value = \"\";\n    this.filterValue = this.filterValue.filter((item) => item?.['value'] && cleanString(item?.['value']) !== cleanString(filter));\n    if(this.filterValue.length === 0) {\n      this.step = 1;\n      this.lastFilter = {};\n    }\n    this.handleFocus(this.indexes);\n  }\n\n  /**\n   * @description Resets the component to its initial state.\n   * @summary Clears all filter data, options, and resets the step counter to 1.\n   * This method provides a clean slate for new filter creation without emitting events.\n   *\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  reset(): void {\n    this.options = this.filteredOptions = this.filterValue = [];\n    this.step = 1;\n    this.lastFilter = {};\n    this.value = '';\n    setTimeout(() => {\n       this.submit();\n    }, 100);\n  }\n\n  /**\n   * @description Clears all filters and notifies parent components.\n   * @summary Resets the component state and emits undefined to notify parent components\n   * that all filters have been cleared. This triggers any connected data refresh logic.\n   *\n   * @param {string} value - Optional parameter (currently unused)\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  clear(value?: string): void {\n    if(!value)\n      this.reset();\n  }\n\n  /**\n   * @description Submits the current filter collection to parent components.\n   * @summary Emits the current filter array to parent components when filters are ready\n   * to be applied. Only emits if there are active filters. Clears options after submission.\n   *\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  submit(): void {\n    this.filterEvent.emit({\n      query: this.filterValue.length > 0 ? this.filterValue : undefined,\n      sort: {\n        value: this.sortValue,\n        direction: this.sortDirection\n      }\n    } as IFilterQuery);\n    if(this.filterValue.length === 0)\n      this.options = [];\n  }\n\n  /**\n   * @description Toggles the sort direction between ascending and descending.\n   * @summary Handles sort direction changes by toggling between ASC and DSC values.\n   * When the direction changes, automatically triggers a submit to apply the new\n   * sorting configuration to the filtered results.\n   *\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n   handleSortDirectionChange(): void {\n    const direction = this.sortDirection ===  OrderDirection.ASC ? OrderDirection.DSC : OrderDirection.ASC;\n    if(direction !== this.sortDirection) {\n      this.sortDirection = direction;\n      this.submit();\n    }\n  }\n\n  /**\n   * @description Handles sort field selection changes from the dropdown.\n   * @summary Processes sort field changes when users select a different field\n   * from the sort dropdown. Updates the sortValue property and triggers\n   * a submit to apply the new sorting configuration if the value has changed.\n   *\n   * @param {CustomEvent} event - The select change event containing the new sort field value\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  handleSortChange(event: CustomEvent): void {\n    const target = event.target as HTMLIonSelectElement;\n    const value = target.value;\n    if(value !== this.sortValue) {\n      this.sortValue = value as string;\n      this.submit();\n    }\n  }\n\n  /**\n   * @description Filters available options based on user input with visual highlighting.\n   * @summary Performs real-time filtering of available options based on user input.\n   * Also handles visual highlighting of matching options in the dropdown. Returns all\n   * options if input is less than 2 characters for performance optimization.\n   *\n   * @param {string | null | undefined} value - The search value to filter by\n   * @returns {string[]} Array of filtered options that match the input\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant U as User\n   *   participant F as FilterComponent\n   *   participant D as DOM\n   *\n   *   U->>F: filterOptions(inputValue)\n   *   alt inputValue < 2 characters\n   *     F->>D: Remove existing highlights\n   *     F-->>U: Return all options\n   *   else inputValue >= 2 characters\n   *     F->>D: Query all option elements\n   *     F->>D: Add highlight to first matching option\n   *     F->>F: Filter options by substring match\n   *     F-->>U: Return filtered options\n   *   end\n   *\n   * @memberOf FilterComponent\n   */\n  filterOptions(value: string | null |  undefined): string[] {\n    const optionsElement = this.optionsFilterElement.nativeElement;\n    if(!value?.length || !value || value.length < 2) {\n      const filteredOption = optionsElement.querySelector('.dcf-filtering-item');\n      if(filteredOption)\n        filteredOption.classList.remove('dcf-filtering-item');\n      return this.options;\n    }\n    const options = optionsElement.querySelectorAll('.dcf-item');\n    for (const option of options) {\n      const isActive = option.textContent?.toLowerCase().includes(value.toLowerCase());\n      if(isActive) {\n        option.classList.add('dcf-filtering-item');\n        break;\n      }\n    }\n    return this.options.filter((option: string) => option.toLowerCase().includes(value.toLowerCase() as string));\n  }\n\n  /**\n   * @description Handles search events from the integrated searchbar component.\n   * @summary Processes search input from the searchbar and emits search events\n   * to parent components. This method acts as a bridge between the internal\n   * searchbar component and external search event listeners.\n   *\n   * @param {string | undefined} value - The search value entered by the user\n   * @returns {void}\n   * @memberOf FilterComponent\n   */\n  handleSearch(value: string | undefined): void {\n    this.searchEvent.emit(value);\n  }\n\n}\n","\n@if(!indexes.length) {\n  <ngx-decaf-searchbar [emitEventToWindow]=\"false\" [debounce]=\"500\" (searchEvent)=\"handleSearch($event)\" />\n}\n\n<div class=\"dcf-grid dcf-grid-small dcf-grid-match dcf-filter-grid\" [ngClass]=\"{'dcf-hidden': !indexes.length}\">\n  <div class=\"dcf-width-expand\">\n    <div class=\"dcf-filter\">\n      <div class=\"dcf-input\">\n        @for(filter of filterValue; track trackItemFn($index, filter?.['index'])) {\n          @if(filter?.['index']) {\n            <ion-chip [outline]=\"true\">{{ filter?.['index'] }}</ion-chip>\n          }\n          @if(filter?.['condition']) {\n            <ion-chip [outline]=\"true\">{{ filter?.['condition'] }}</ion-chip>\n          }\n          @if(filter?.['value']) {\n            <ion-chip [outline]=\"true\" class=\"dcf-filter-value\">\n              {{ filter?.['value'] }}\n              <ion-icon name=\"close\" (click)=\"removeFilter(filter?.['value'])\" size=\"small\"></ion-icon>\n            </ion-chip>\n          }\n        }\n        <div class=\"dcf-width-1-1\">\n          <input\n            fill=\"none\"\n            [(ngModel)]=\"value\"\n            (keydown.enter)=\"addFilter(value, $event)\"\n            (keydown.backspace)=\"clear(value)\"\n            (input)=\"handleInput($event)\"\n            (click)=\"handleFocus()\"\n            (blur)=\"handleBlur()\"\n            type=\"text\"\n            [readonly]=\"step !== 3\"\n            placeholder=\"{{ locale + (step === 3 ? '.type' : '.select') | translate }}\"\n            #component\n          />\n          @if(windowWidth >= 768) {\n            <div [class]=\"'dcf-dropdown ' + (options.length > 0 ? ' dcf-active' : '')\" #optionsFilterElement>\n              <div>\n                @if(filteredOptions.length > 0) {\n                  @for(key of filteredOptions; track key) {\n                    <div\n                      class=\"dcf-item\"\n                      tabindex=\"0\"\n                      (keydown.enter)=\"selectOption(key)\"\n                      (click)=\"selectOption(key)\">\n                      {{ key }}\n                    </div>\n                  }\n                } @else {\n                  <div class=\"dcf-empty\"\n                    (click)=\"filteredOptions = options; value = ''\"\n                    tabindex=\"0\"\n                    (keydown.enter)=\"filteredOptions = options; value = ''\"\n                  >\n                    {{ 'no_suggestions' | translate }}\n                  </div>\n                }\n              </div>\n            </div>\n          }\n        </div>\n      </div>\n      @if(filterValue.length > 0) {\n        <div class=\"dcf-icon-clear\">\n          <ion-button fill=\"clear\" size=\"small\" (click)=\"clear()\">\n            <ion-icon name=\"trash-outline\" color=\"dark\" slot=\"icon-only\"></ion-icon>\n          </ion-button>\n        </div>\n      }\n      <div class=\"dcf-icon-search\">\n        <ion-button fill=\"clear\" size=\"small\" (click)=\"submit()\">\n          <ion-icon name=\"search-outline\" color=\"dark\" slot=\"icon-only\"></ion-icon>\n        </ion-button>\n      </div>\n    </div>\n    @if(windowWidth < 768) {\n      <div [class]=\"'dcf-dropdown ' + (options.length > 0 ? ' dcf-active' : '')\" #optionsFilterElement>\n        <div>\n          @if(filteredOptions.length > 0) {\n            @for(key of filteredOptions; track key) {\n              <div\n                class=\"dcf-item\"\n                tabindex=\"0\"\n                (keydown.enter)=\"selectOption(key)\"\n                (click)=\"selectOption(key)\">\n                {{ key }}\n              </div>\n            }\n          } @else {\n            <div class=\"dcf-empty\"\n            (click)=\"filteredOptions = options; value = ''\"\n            tabindex=\"0\"\n            (keydown.enter)=\"filteredOptions = options; value = ''\"\n            >\n              {{ 'no_suggestions' | translate }}\n            </div>\n          }\n        </div>\n      </div>\n    }\n  </div>\n  @if(!disableSort) {\n    <div class=\"dcf-width-1-5@m dcf-width-1-1 dcf-sort-container\">\n      <div class=\"dcf-grid dcf-grid-collapse dcf-flex dcf-flex-middle dcf-grid-match\">\n        <div class=\"dcf-width-expand\">\n          <ion-select\n              toggleIcon=\"chevron-down-outline\"\n              expandedIcon=\"chevron-up-outline\"\n              class=\"dcf-sort-select\"\n              (ionChange)=\"handleSortChange($event)\"\n              interface=\"popover\"\n              [value]=\"sortValue\"\n              label-placement=\"floating\"\n              fill=\"outline\"\n            >\n            @for(sort of sortBy; track sort) {\n              aa\n              <ion-select-option [value]=\"sort\">{{ sort | translate }}</ion-select-option>\n            }\n          </ion-select>\n        </div>\n        <div class=\"dcf-width-auto\">\n          <ion-button (click)=\"handleSortDirectionChange()\" fill=\"clear\">\n            <ion-icon slot=\"icon-only\" [name]=\"sortDirection === 'desc' ? 'arrow-down-outline' : 'arrow-up-outline'\"></ion-icon>\n          </ion-button>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n\n\n"]}