@elite.framework/ng.ui.core 1.0.90 → 1.0.93

package/fesm2022/elite.framework-ng.ui.core-generic-search-advanced.mjs

@@ -1152,6 +1152,15 @@ class QueryBuilderComponent extends FieldType {
             this.initializeDefaultConditions();
         }
     }
+    initializeConditionsWithFieldConfigs(conditions, groupIndex) {
+        return conditions.map((condition, conditionIndex) => ({
+            ...condition,
+            operatorsForField: this.getOperatorsForField(condition.field),
+            valueFieldConfig: condition.field ?
+                this.generateValueFieldConfig(condition, groupIndex, conditionIndex) :
+                null
+        }));
+    }
     getLogicalOperatorText(operator) {
         const operatorMap = {
             'and': this.translate.instant('and'),
@@ -1166,7 +1175,7 @@ class QueryBuilderComponent extends FieldType {
         const defaultConditions = [];
         for (let i = 0; i < defaultFields.length; i++) {
             const field = defaultFields[i];
-            defaultConditions.push(this.createDefaultCondition(field, 0, i));
+            defaultConditions.push(this.createDefaultCondition(field, 0, i, field.props?.operator));
         }
         this.groups = [{
                 logicalOperator: 'and',
@@ -1187,17 +1196,17 @@ class QueryBuilderComponent extends FieldType {
     }
     isSupportedFieldType(fieldType) {
         // Only include field types that make sense for filtering
-        const supportedTypes = ['input', 'number', 'datepicker', 'select', 'checkbox', 'generic-selector', 'switch', 'radio', 'textarea'];
+        const supportedTypes = ['input', 'number', 'datepicker', 'custom-datepicker', 'select', 'checkbox', 'generic-selector', 'switch', 'radio', 'textarea'];
         return supportedTypes.includes(fieldType);
     }
     getFieldLabel(key) {
         const f = this.props['fields']?.find((x) => x.key === key);
         return f ? f.label : '';
     }
-    createDefaultCondition(field, groupIndex, conditionIndex) {
+    createDefaultCondition(field, groupIndex, conditionIndex, operator) {
         const defaultCondition = {
             field: field.key,
-            operator: this.getDefaultOperator(field.type),
+            operator: operator ? operator : this.getDefaultOperator(field.type),
             value: this.getDefaultValue(field.type),
             valueFieldConfig: null,
             operatorsForField: this.getOperatorsForField(field),
@@ -1206,15 +1215,6 @@ class QueryBuilderComponent extends FieldType {
         defaultCondition.valueFieldConfig = this.generateValueFieldConfig(defaultCondition, groupIndex, conditionIndex);
         return defaultCondition;
     }
-    initializeConditionsWithFieldConfigs(conditions, groupIndex) {
-        return conditions.map((condition, conditionIndex) => ({
-            ...condition,
-            operatorsForField: this.getOperatorsForField(condition.field),
-            valueFieldConfig: condition.field ?
-                this.generateValueFieldConfig(condition, groupIndex, conditionIndex) :
-                null
-        }));
-    }
     // Field type and operator methods that use QueryBuilderService logic
     getFieldType(fieldKey) {
         const field = this.props['fields'].find((f) => f.key === fieldKey);
@@ -1313,9 +1313,33 @@ class QueryBuilderComponent extends FieldType {
         });
         this.updateValue();
     }
+    // removeGroup(groupIndex: number) {
+    //   this.groups.splice(groupIndex, 1);
+    //   this.updateValue();
+    // }
     removeGroup(groupIndex) {
-        this.groups.splice(groupIndex, 1);
-        this.updateValue();
+        if (this.groups[groupIndex]) {
+            // Get all field keys for this group before deleting
+            const fieldKeysToRemove = [];
+            // Collect all condition field keys in this group
+            if (this.groups[groupIndex].conditions) {
+                for (let c = 0; c < this.groups[groupIndex].conditions.length; c++) {
+                    const fieldKey = this.getConditionValueKey(groupIndex, c);
+                    fieldKeysToRemove.push(fieldKey);
+                }
+            }
+            // Remove the group
+            this.groups.splice(groupIndex, 1);
+            // Remove all associated fields from model
+            this.removeMultipleFromModel(fieldKeysToRemove);
+            this.updateValue();
+        }
+    }
+    // Remove multiple fields from formly model
+    removeMultipleFromModel(fieldKeys) {
+        fieldKeys.forEach(fieldKey => {
+            this.removeFromModel(fieldKey);
+        });
     }
     // Condition Management
     addCondition(groupIndex = 0) {
@@ -1353,14 +1377,35 @@ class QueryBuilderComponent extends FieldType {
     }
     removeCondition(groupIndex, conditionIndex) {
         if (this.groups[groupIndex]) {
-            this.groups[groupIndex].conditions.splice(conditionIndex, 1);
+            // Get the field key before deleting so we can remove from model
+            const fieldKey = this.getConditionValueKey(groupIndex, conditionIndex);
+            // Using delete operator (sets to undefined, then we filter)
+            delete this.groups[groupIndex].conditions[conditionIndex];
+            // Remove the undefined entries from conditions array
+            this.groups[groupIndex].conditions = this.groups[groupIndex].conditions.filter((condition) => condition !== undefined);
             // Remove empty groups
             if (this.groups[groupIndex].conditions.length === 0 && this.groups.length > 1) {
-                this.removeGroup(groupIndex);
+                delete this.groups[groupIndex];
+                // Remove undefined groups from array
+                this.groups = this.groups.filter(group => group !== undefined);
             }
+            // Remove from formly model
+            this.removeFromModel(fieldKey);
             this.updateValue();
         }
     }
+    // Remove the field from formly model
+    removeFromModel(fieldKey) {
+        if (this.model && this.model.hasOwnProperty(fieldKey)) {
+            delete this.model[fieldKey];
+        }
+        // Also update the form control to ensure sync
+        if (this.formControl.value && this.formControl.value.hasOwnProperty(fieldKey)) {
+            const updatedValue = { ...this.formControl.value };
+            delete updatedValue[fieldKey];
+            this.formControl.setValue(updatedValue);
+        }
+    }
     // Value Management
     updateValue() {
         // Sync condition values from form model with safe access
@@ -1369,9 +1414,13 @@ class QueryBuilderComponent extends FieldType {
             for (let c = 0; c < group.conditions.length; c++) {
                 const condition = group.conditions[c];
                 const fieldKey = this.getConditionValueKey(g, c);
-                const modelValue = this.model?.[fieldKey];
-                if (modelValue !== undefined) {
-                    condition.value = modelValue;
+                try {
+                    const modelValue = this.model?.[fieldKey];
+                    if (modelValue !== undefined) {
+                        condition.value = modelValue;
+                    }
+                }
+                catch (error) {
                 }
             }
         }
@@ -1398,6 +1447,12 @@ class QueryBuilderComponent extends FieldType {
     }
     clearAll() {
         this.groups = [];
+        // Completely reset the form and model
+        this.form.reset();
+        // Manually set model to empty object
+        Object.keys(this.model).forEach(key => {
+            delete this.model[key];
+        });
         this.addGroup();
     }
     // Helper methods