@decaf-ts/for-angular 0.0.10 → 0.0.12

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

@@ -0,0 +1,906 @@
+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";
+const _c0 = ["optionsFilterElement"];
+function _forTrack0($index, $item) { return this.trackItemFn($index, $item == null ? null : $item["index"]); }
+const _c1 = a0 => ({ "dcf-hidden": a0 });
+function FilterComponent_Conditional_0_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "ngx-decaf-searchbar", 15);
+    i0.ɵɵlistener("searchEvent", function FilterComponent_Conditional_0_Template_ngx_decaf_searchbar_searchEvent_0_listener($event) { i0.ɵɵrestoreView(_r2); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.handleSearch($event)); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵproperty("emitEventToWindow", false)("debounce", 500);
+} }
+function FilterComponent_For_6_Conditional_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "ion-chip", 16);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const filter_r4 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵproperty("outline", true);
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(filter_r4 == null ? null : filter_r4["index"]);
+} }
+function FilterComponent_For_6_Conditional_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "ion-chip", 16);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const filter_r4 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵproperty("outline", true);
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(filter_r4 == null ? null : filter_r4["condition"]);
+} }
+function FilterComponent_For_6_Conditional_2_Template(rf, ctx) { if (rf & 1) {
+    const _r5 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "ion-chip", 17);
+    i0.ɵɵtext(1);
+    i0.ɵɵelementStart(2, "ion-icon", 18);
+    i0.ɵɵlistener("click", function FilterComponent_For_6_Conditional_2_Template_ion_icon_click_2_listener() { i0.ɵɵrestoreView(_r5); const filter_r4 = i0.ɵɵnextContext().$implicit; const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.removeFilter(filter_r4 == null ? null : filter_r4["value"])); });
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const filter_r4 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵproperty("outline", true);
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", filter_r4 == null ? null : filter_r4["value"], " ");
+} }
+function FilterComponent_For_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, FilterComponent_For_6_Conditional_0_Template, 2, 2, "ion-chip", 16)(1, FilterComponent_For_6_Conditional_1_Template, 2, 2, "ion-chip", 16)(2, FilterComponent_For_6_Conditional_2_Template, 3, 2, "ion-chip", 17);
+} if (rf & 2) {
+    const filter_r4 = ctx.$implicit;
+    i0.ɵɵconditional((filter_r4 == null ? null : filter_r4["index"]) ? 0 : -1);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional((filter_r4 == null ? null : filter_r4["condition"]) ? 1 : -1);
+    i0.ɵɵadvance();
+    i0.ɵɵconditional((filter_r4 == null ? null : filter_r4["value"]) ? 2 : -1);
+} }
+function FilterComponent_Conditional_11_Conditional_3_For_1_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 21);
+    i0.ɵɵlistener("keydown.enter", function FilterComponent_Conditional_11_Conditional_3_For_1_Template_div_keydown_enter_0_listener() { const key_r7 = i0.ɵɵrestoreView(_r6).$implicit; const ctx_r2 = i0.ɵɵnextContext(3); return i0.ɵɵresetView(ctx_r2.selectOption(key_r7)); })("click", function FilterComponent_Conditional_11_Conditional_3_For_1_Template_div_click_0_listener() { const key_r7 = i0.ɵɵrestoreView(_r6).$implicit; const ctx_r2 = i0.ɵɵnextContext(3); return i0.ɵɵresetView(ctx_r2.selectOption(key_r7)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const key_r7 = ctx.$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", key_r7, " ");
+} }
+function FilterComponent_Conditional_11_Conditional_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵrepeaterCreate(0, FilterComponent_Conditional_11_Conditional_3_For_1_Template, 2, 1, "div", 20, i0.ɵɵrepeaterTrackByIdentity);
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵrepeater(ctx_r2.filteredOptions);
+} }
+function FilterComponent_Conditional_11_Conditional_4_Template(rf, ctx) { if (rf & 1) {
+    const _r8 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 22);
+    i0.ɵɵlistener("click", function FilterComponent_Conditional_11_Conditional_4_Template_div_click_0_listener() { i0.ɵɵrestoreView(_r8); const ctx_r2 = i0.ɵɵnextContext(2); ctx_r2.filteredOptions = ctx_r2.options; return i0.ɵɵresetView(ctx_r2.value = ""); })("keydown.enter", function FilterComponent_Conditional_11_Conditional_4_Template_div_keydown_enter_0_listener() { i0.ɵɵrestoreView(_r8); const ctx_r2 = i0.ɵɵnextContext(2); ctx_r2.filteredOptions = ctx_r2.options; return i0.ɵɵresetView(ctx_r2.value = ""); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 1, "no_suggestions"), " ");
+} }
+function FilterComponent_Conditional_11_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", null, 1)(2, "div");
+    i0.ɵɵtemplate(3, FilterComponent_Conditional_11_Conditional_3_Template, 2, 0)(4, FilterComponent_Conditional_11_Conditional_4_Template, 3, 3, "div", 19);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵclassMap("dcf-dropdown " + (ctx_r2.options.length > 0 ? " dcf-active" : ""));
+    i0.ɵɵadvance(3);
+    i0.ɵɵconditional(ctx_r2.filteredOptions.length > 0 ? 3 : 4);
+} }
+function FilterComponent_Conditional_12_Template(rf, ctx) { if (rf & 1) {
+    const _r9 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 10)(1, "ion-button", 12);
+    i0.ɵɵlistener("click", function FilterComponent_Conditional_12_Template_ion_button_click_1_listener() { i0.ɵɵrestoreView(_r9); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.clear()); });
+    i0.ɵɵelement(2, "ion-icon", 23);
+    i0.ɵɵelementEnd()();
+} }
+function FilterComponent_Conditional_16_Conditional_3_For_1_Template(rf, ctx) { if (rf & 1) {
+    const _r10 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 21);
+    i0.ɵɵlistener("keydown.enter", function FilterComponent_Conditional_16_Conditional_3_For_1_Template_div_keydown_enter_0_listener() { const key_r11 = i0.ɵɵrestoreView(_r10).$implicit; const ctx_r2 = i0.ɵɵnextContext(3); return i0.ɵɵresetView(ctx_r2.selectOption(key_r11)); })("click", function FilterComponent_Conditional_16_Conditional_3_For_1_Template_div_click_0_listener() { const key_r11 = i0.ɵɵrestoreView(_r10).$implicit; const ctx_r2 = i0.ɵɵnextContext(3); return i0.ɵɵresetView(ctx_r2.selectOption(key_r11)); });
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const key_r11 = ctx.$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", key_r11, " ");
+} }
+function FilterComponent_Conditional_16_Conditional_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵrepeaterCreate(0, FilterComponent_Conditional_16_Conditional_3_For_1_Template, 2, 1, "div", 20, i0.ɵɵrepeaterTrackByIdentity);
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵrepeater(ctx_r2.filteredOptions);
+} }
+function FilterComponent_Conditional_16_Conditional_4_Template(rf, ctx) { if (rf & 1) {
+    const _r12 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 22);
+    i0.ɵɵlistener("click", function FilterComponent_Conditional_16_Conditional_4_Template_div_click_0_listener() { i0.ɵɵrestoreView(_r12); const ctx_r2 = i0.ɵɵnextContext(2); ctx_r2.filteredOptions = ctx_r2.options; return i0.ɵɵresetView(ctx_r2.value = ""); })("keydown.enter", function FilterComponent_Conditional_16_Conditional_4_Template_div_keydown_enter_0_listener() { i0.ɵɵrestoreView(_r12); const ctx_r2 = i0.ɵɵnextContext(2); ctx_r2.filteredOptions = ctx_r2.options; return i0.ɵɵresetView(ctx_r2.value = ""); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 1, "no_suggestions"), " ");
+} }
+function FilterComponent_Conditional_16_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", null, 1)(2, "div");
+    i0.ɵɵtemplate(3, FilterComponent_Conditional_16_Conditional_3_Template, 2, 0)(4, FilterComponent_Conditional_16_Conditional_4_Template, 3, 3, "div", 19);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵclassMap("dcf-dropdown " + (ctx_r2.options.length > 0 ? " dcf-active" : ""));
+    i0.ɵɵadvance(3);
+    i0.ɵɵconditional(ctx_r2.filteredOptions.length > 0 ? 3 : 4);
+} }
+function FilterComponent_Conditional_17_For_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtext(0, " aa ");
+    i0.ɵɵelementStart(1, "ion-select-option", 26);
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const sort_r14 = ctx.$implicit;
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("value", sort_r14);
+    i0.ɵɵadvance();
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 2, sort_r14));
+} }
+function FilterComponent_Conditional_17_Template(rf, ctx) { if (rf & 1) {
+    const _r13 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 14)(1, "div", 24)(2, "div", 4)(3, "ion-select", 25);
+    i0.ɵɵlistener("ionChange", function FilterComponent_Conditional_17_Template_ion_select_ionChange_3_listener($event) { i0.ɵɵrestoreView(_r13); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.handleSortChange($event)); });
+    i0.ɵɵrepeaterCreate(4, FilterComponent_Conditional_17_For_5_Template, 4, 4, "ion-select-option", 26, i0.ɵɵrepeaterTrackByIdentity);
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(6, "div", 27)(7, "ion-button", 28);
+    i0.ɵɵlistener("click", function FilterComponent_Conditional_17_Template_ion_button_click_7_listener() { i0.ɵɵrestoreView(_r13); const ctx_r2 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r2.handleSortDirectionChange()); });
+    i0.ɵɵelement(8, "ion-icon", 29);
+    i0.ɵɵelementEnd()()()();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("value", ctx_r2.sortValue);
+    i0.ɵɵadvance();
+    i0.ɵɵrepeater(ctx_r2.sortBy);
+    i0.ɵɵadvance(4);
+    i0.ɵɵproperty("name", ctx_r2.sortDirection === "desc" ? "arrow-down-outline" : "arrow-up-outline");
+} }
+/**
+ * @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 = function FilterComponent_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || FilterComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FilterComponent, selectors: [["ngx-decaf-filter"]], viewQuery: function FilterComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5, ElementRef);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.optionsFilterElement = _t.first);
+        } }, inputs: { indexes: "indexes", conditions: "conditions", sortBy: "sortBy", disableSort: "disableSort" }, outputs: { filterEvent: "filterEvent", searchEvent: "searchEvent" }, standalone: true, features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵStandaloneFeature], decls: 18, vars: 13, consts: [["component", ""], ["optionsFilterElement", ""], [3, "emitEventToWindow", "debounce"], [1, "dcf-grid", "dcf-grid-small", "dcf-grid-match", "dcf-filter-grid", 3, "ngClass"], [1, "dcf-width-expand"], [1, "dcf-filter"], [1, "dcf-input"], [1, "dcf-width-1-1"], ["fill", "none", "type", "text", 3, "ngModelChange", "keydown.enter", "keydown.backspace", "input", "click", "blur", "ngModel", "readonly", "placeholder"], [3, "class"], [1, "dcf-icon-clear"], [1, "dcf-icon-search"], ["fill", "clear", "size", "small", 3, "click"], ["name", "search-outline", "color", "dark", "slot", "icon-only"], [1, "dcf-width-1-5@m", "dcf-width-1-1", "dcf-sort-container"], [3, "searchEvent", "emitEventToWindow", "debounce"], [3, "outline"], [1, "dcf-filter-value", 3, "outline"], ["name", "close", "size", "small", 3, "click"], ["tabindex", "0", 1, "dcf-empty"], ["tabindex", "0", 1, "dcf-item"], ["tabindex", "0", 1, "dcf-item", 3, "keydown.enter", "click"], ["tabindex", "0", 1, "dcf-empty", 3, "click", "keydown.enter"], ["name", "trash-outline", "color", "dark", "slot", "icon-only"], [1, "dcf-grid", "dcf-grid-collapse", "dcf-flex", "dcf-flex-middle", "dcf-grid-match"], ["toggleIcon", "chevron-down-outline", "expandedIcon", "chevron-up-outline", "interface", "popover", "label-placement", "floating", "fill", "outline", 1, "dcf-sort-select", 3, "ionChange", "value"], [3, "value"], [1, "dcf-width-auto"], ["fill", "clear", 3, "click"], ["slot", "icon-only", 3, "name"]], template: function FilterComponent_Template(rf, ctx) { if (rf & 1) {
+            const _r1 = i0.ɵɵgetCurrentView();
+            i0.ɵɵtemplate(0, FilterComponent_Conditional_0_Template, 1, 2, "ngx-decaf-searchbar", 2);
+            i0.ɵɵelementStart(1, "div", 3)(2, "div", 4)(3, "div", 5)(4, "div", 6);
+            i0.ɵɵrepeaterCreate(5, FilterComponent_For_6_Template, 3, 3, null, null, _forTrack0, true);
+            i0.ɵɵelementStart(7, "div", 7)(8, "input", 8, 0);
+            i0.ɵɵpipe(10, "translate");
+            i0.ɵɵtwoWayListener("ngModelChange", function FilterComponent_Template_input_ngModelChange_8_listener($event) { i0.ɵɵrestoreView(_r1); i0.ɵɵtwoWayBindingSet(ctx.value, $event) || (ctx.value = $event); return i0.ɵɵresetView($event); });
+            i0.ɵɵlistener("keydown.enter", function FilterComponent_Template_input_keydown_enter_8_listener($event) { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.addFilter(ctx.value, $event)); })("keydown.backspace", function FilterComponent_Template_input_keydown_backspace_8_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.clear(ctx.value)); })("input", function FilterComponent_Template_input_input_8_listener($event) { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.handleInput($event)); })("click", function FilterComponent_Template_input_click_8_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.handleFocus()); })("blur", function FilterComponent_Template_input_blur_8_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.handleBlur()); });
+            i0.ɵɵelementEnd();
+            i0.ɵɵtemplate(11, FilterComponent_Conditional_11_Template, 5, 3, "div", 9);
+            i0.ɵɵelementEnd()();
+            i0.ɵɵtemplate(12, FilterComponent_Conditional_12_Template, 3, 0, "div", 10);
+            i0.ɵɵelementStart(13, "div", 11)(14, "ion-button", 12);
+            i0.ɵɵlistener("click", function FilterComponent_Template_ion_button_click_14_listener() { i0.ɵɵrestoreView(_r1); return i0.ɵɵresetView(ctx.submit()); });
+            i0.ɵɵelement(15, "ion-icon", 13);
+            i0.ɵɵelementEnd()()();
+            i0.ɵɵtemplate(16, FilterComponent_Conditional_16_Template, 5, 3, "div", 9);
+            i0.ɵɵelementEnd();
+            i0.ɵɵtemplate(17, FilterComponent_Conditional_17_Template, 9, 2, "div", 14);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵconditional(!ctx.indexes.length ? 0 : -1);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(11, _c1, !ctx.indexes.length));
+            i0.ɵɵadvance(4);
+            i0.ɵɵrepeater(ctx.filterValue);
+            i0.ɵɵadvance(3);
+            i0.ɵɵpropertyInterpolate("placeholder", i0.ɵɵpipeBind1(10, 9, ctx.locale + (ctx.step === 3 ? ".type" : ".select")));
+            i0.ɵɵtwoWayProperty("ngModel", ctx.value);
+            i0.ɵɵproperty("readonly", ctx.step !== 3);
+            i0.ɵɵadvance(3);
+            i0.ɵɵconditional(ctx.windowWidth >= 768 ? 11 : -1);
+            i0.ɵɵadvance();
+            i0.ɵɵconditional(ctx.filterValue.length > 0 ? 12 : -1);
+            i0.ɵɵadvance(4);
+            i0.ɵɵconditional(ctx.windowWidth < 768 ? 16 : -1);
+            i0.ɵɵadvance();
+            i0.ɵɵconditional(!ctx.disableSort ? 17 : -1);
+        } }, dependencies: [ForAngularModule, i1.IonButton, i2.NgClass, i3.DefaultValueAccessor, i3.NgControlStatus, i3.NgModel, i4.TranslatePipe, IonChip,
+            IonIcon,
+            IonSelect,
+            SearchbarComponent], styles: [".dcf-filter-grid[_ngcontent-%COMP%]{padding:0 .5rem;margin-top:.75rem;margin-bottom:.75rem}ion-select[_ngcontent-%COMP%]{min-height:44px!important}.dcf-hidden[_ngcontent-%COMP%]{display:none!important}.dcf-filter[_ngcontent-%COMP%]{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[_ngcontent-%COMP%]:focus-within{border-color:var(--ion-color-primary);background-color:#fff}.dcf-filter[_ngcontent-%COMP%]   ion-chip[_ngcontent-%COMP%]{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[_ngcontent-%COMP%]   ion-chip.dcf-filter-value[_ngcontent-%COMP%]{background:var(--ion-color-gray-2);border-color:var(--ion-color-gray-4)!important;color:var(--ion-color-gray-8)!important}.dcf-filter[_ngcontent-%COMP%]   ion-chip.sc-ion-chip-md-h[_ngcontent-%COMP%], .dcf-filter[_ngcontent-%COMP%]   ion-chip.sc-ion-chip-ios-h[_ngcontent-%COMP%]{height:24px;min-height:24px}.dcf-filter[_ngcontent-%COMP%]   ion-chip.sc-ion-chip-md-h[_ngcontent-%COMP%]   .chip-native[_ngcontent-%COMP%], .dcf-filter[_ngcontent-%COMP%]   ion-chip.sc-ion-chip-ios-h[_ngcontent-%COMP%]   .chip-native[_ngcontent-%COMP%]{padding:0 8px!important;height:24px;min-height:24px}.dcf-filter[_ngcontent-%COMP%]   ion-chip[_ngcontent-%COMP%]   ion-label[_ngcontent-%COMP%]{padding:0 4px;margin:0;font-size:.75rem;white-space:nowrap}.dcf-filter[_ngcontent-%COMP%]   ion-chip[_ngcontent-%COMP%]   ion-icon[_ngcontent-%COMP%]{margin:0 2px;font-size:.75rem}.dcf-filter[_ngcontent-%COMP%]   .dcf-input[_ngcontent-%COMP%]{width:100%;display:flex;align-items:center;overflow-x:auto;overflow-y:hidden;white-space:nowrap;padding-left:.5rem}.dcf-filter[_ngcontent-%COMP%]   .dcf-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]{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[_ngcontent-%COMP%]   .dcf-input[_ngcontent-%COMP%]   input[_ngcontent-%COMP%]:focus{border:0px!important;outline:none!important}.dcf-filter[_ngcontent-%COMP%]   .dcf-icon-clear[_ngcontent-%COMP%], .dcf-filter[_ngcontent-%COMP%]   .dcf-icon-search[_ngcontent-%COMP%]{display:flex;justify-content:center;text-align:center;align-items:center;min-width:40px}.dcf-filter[_ngcontent-%COMP%]   .dcf-icon-search[_ngcontent-%COMP%]   ion-icon[_ngcontent-%COMP%]{font-size:1.25rem}.dcf-sort-container[_ngcontent-%COMP%]{min-width:200px!important;width:auto}@media (min-width: 990px){.dcf-sort-container[_ngcontent-%COMP%]{max-width:20%!important}}@media (max-width: 680px){.dcf-sort-container[_ngcontent-%COMP%]{min-width:100%!important;margin:.75rem 0rem}}.dcf-dropdown[_ngcontent-%COMP%]{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[_ngcontent-%COMP%]{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[_ngcontent-%COMP%]{margin-top:55px}}.dcf-dropdown.dcf-active[_ngcontent-%COMP%] > div[_ngcontent-%COMP%] > div[_ngcontent-%COMP%]{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[_ngcontent-%COMP%] > div[_ngcontent-%COMP%] > div.dcf-filtering-item[_ngcontent-%COMP%], .dcf-dropdown.dcf-active[_ngcontent-%COMP%] > div[_ngcontent-%COMP%] > div[_ngcontent-%COMP%]:only-child{border-color:var(--ion-color-primary)}.dcf-dropdown.dcf-active[_ngcontent-%COMP%] > div[_ngcontent-%COMP%] > div.dcf-filtering-item.dcf-empty[_ngcontent-%COMP%], .dcf-dropdown.dcf-active[_ngcontent-%COMP%] > div[_ngcontent-%COMP%] > div[_ngcontent-%COMP%]:only-child.dcf-empty{border-color:var(--ion-color-gray-7)!important}.dcf-dropdown.dcf-active[_ngcontent-%COMP%] > div[_ngcontent-%COMP%] > div[_ngcontent-%COMP%]:hover{background-color:var(--ion-color-gray-1)}"] }); }
+};
+FilterComponent = __decorate([
+    Dynamic(),
+    __metadata("design:paramtypes", [])
+], FilterComponent);
+export { FilterComponent };
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FilterComponent, [{
+        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"] }]
+    }], () => [], { 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
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(FilterComponent, { className: "FilterComponent", filePath: "components/filter/filter.component.ts", lineNumber: 72 }); })();
+//# 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"]}