@syncfusion/ej2-querybuilder 30.1.41 → 30.2.4

package/dist/es6/ej2-querybuilder.es2015.js

@@ -1,4 +1,4 @@
-import { ChildProperty, Property, Collection, Component, getComponent, removeClass, isNullOrUndefined, Animation, extend, closest, addClass, select, append, detach, rippleEffect, getInstance, getValue, getNumericObject, Browser, classList, Internationalization, getUniqueID, L10n, Draggable, remove, compile, EventHandler, cldrData, Event, Complex, NotifyPropertyChanges } from '@syncfusion/ej2-base';
+import { ChildProperty, Property, Collection, Component, removeClass, isNullOrUndefined, Animation, extend, closest, addClass, select, append, getComponent, detach, rippleEffect, getInstance, getValue, getNumericObject, Browser, classList, Internationalization, getUniqueID, L10n, Draggable, remove, compile, EventHandler, cldrData, Event, Complex, NotifyPropertyChanges } from '@syncfusion/ej2-base';
 import { Button, CheckBox, RadioButton } from '@syncfusion/ej2-buttons';
 import { MultiSelect, CheckBoxSelection, DropDownList, DropDownTree } from '@syncfusion/ej2-dropdowns';
 import { Query, DataManager, Deferred, Predicate } from '@syncfusion/ej2-data';
@@ -174,37 +174,71 @@ let QueryBuilder = class QueryBuilder extends Component {
     reset() {
         this.isImportRules = false;
         let bodyElem = this.element.querySelector('.e-group-body');
-        const inputElement = this.element.querySelectorAll('input.e-control');
-        for (let i = 0, len = inputElement.length; i < len; i++) {
-            if (inputElement[i].className.indexOf('e-tooltip') > -1) {
-                getComponent(inputElement[i], 'tooltip').destroy();
+        const inputElements = this.element.querySelectorAll('input.e-control');
+        const batchSize = 20;
+        let currentIndex = 0;
+        const processBatch = () => {
+            const endIndex = Math.min(currentIndex + batchSize, inputElements.length);
+            for (let i = currentIndex; i < endIndex; i++) {
+                const element = inputElements[i];
+                try {
+                    if (element.className.indexOf('e-tooltip') > -1) {
+                        const tooltip = getComponent(element, 'tooltip');
+                        if (tooltip) {
+                            tooltip.destroy();
+                        }
+                    }
+                    else if (element.parentElement && element.parentElement.className.indexOf('e-tooltip') > -1) {
+                        const tooltip = getComponent(element.parentElement, 'tooltip');
+                        if (tooltip) {
+                            tooltip.destroy();
+                        }
+                    }
+                }
+                catch (e) {
+                    console.warn('Error destroying tooltip:', e);
+                }
             }
-            else if (inputElement[i].parentElement.className.indexOf('e-tooltip') > -1) {
-                getComponent(inputElement[i].parentElement, 'tooltip').destroy();
+            currentIndex = endIndex;
+            if (currentIndex < inputElements.length) {
+                requestAnimationFrame(processBatch);
             }
+        };
+        if (inputElements.length > 0) {
+            processBatch();
         }
         if (bodyElem) {
-            bodyElem.innerHTML = '';
+            bodyElem.textContent = '';
         }
         else {
+            const fragment = document.createDocumentFragment();
             const grpContainer = this.createElement('div', { attrs: { class: 'e-group-container' } });
             const grpHeader = this.createElement('div', { attrs: { class: 'e-group-header' } });
             const grpBody = this.createElement('div', { attrs: { class: 'e-group-body' } });
-            grpContainer.appendChild(grpHeader).appendChild(grpBody);
-            this.element.appendChild(grpContainer);
+            grpContainer.appendChild(grpHeader);
+            grpContainer.appendChild(grpBody);
+            fragment.appendChild(grpContainer);
+            this.element.appendChild(fragment);
             bodyElem = this.element.querySelector('.e-group-body');
         }
         if (this.headerTemplate && this.isRoot) {
-            this.element.innerHTML = '';
+            this.element.textContent = '';
             this.isRoot = false;
         }
         if (this.enableNotCondition) {
-            removeClass(this.element.querySelectorAll('.e-qb-toggle'), 'e-active-toggle');
+            const toggleElements = this.element.querySelectorAll('.e-qb-toggle');
+            for (let i = 0; i < toggleElements.length; i++) {
+                removeClass([toggleElements[i]], 'e-active-toggle');
+            }
+        }
+        if (bodyElem) {
+            bodyElem.appendChild(this.createElement('div', { attrs: { class: 'e-rule-list' } }));
         }
-        bodyElem.appendChild(this.createElement('div', { attrs: { class: 'e-rule-list' } }));
         this.levelColl[this.element.id + '_group0'] = [0];
         this.setProperties({ rule: { condition: 'and', not: false, rules: [] } }, true);
-        this.disableRuleCondition(bodyElem.parentElement);
+        if (bodyElem && bodyElem.parentElement) {
+            this.disableRuleCondition(bodyElem.parentElement);
+        }
     }
     getWrapper() {
         return this.element;
@@ -239,11 +273,11 @@ let QueryBuilder = class QueryBuilder extends Component {
             if (this.columns.length) {
                 this.columnSort();
                 const columns = this.columns;
-                for (let i = 0, len = columns.length; i < len; i++) {
-                    this.updateCustomOperator(columns[i], 'initial');
-                    if (!columns[i].type) {
-                        if (columnKeys.indexOf(columns[i].field) > -1) {
-                            value = this.dataColl[0][columns[i].field];
+                columns.forEach((column) => {
+                    this.updateCustomOperator(column, 'initial');
+                    if (!column.type) {
+                        if (columnKeys.indexOf(column.field) > -1) {
+                            value = this.dataColl[0][column.field];
                             type = typeof value;
                             if (type === 'string') {
                                 isDate = !isNaN(Date.parse(value));
@@ -252,28 +286,28 @@ let QueryBuilder = class QueryBuilder extends Component {
                                 isDate = value instanceof Date && !isNaN(value.getTime());
                                 type = 'string';
                             }
-                            columns[i].type = type;
+                            column.type = type;
                             isDate = false;
                         }
                         type = 'string';
                     }
-                    if (!columns[i].validation) {
-                        columns[i].validation = validateObj;
+                    if (!column.validation) {
+                        column.validation = validateObj;
                     }
-                    if (columns[i].category) {
+                    if (column.category) {
                         groupBy = true;
                     }
                     else {
-                        columns[i].category = this.l10n.getConstant('OtherFields');
+                        column.category = this.l10n.getConstant('OtherFields');
                     }
-                    if (categories.indexOf(columns[i].category) < 0) {
-                        categories.push(columns[i].category);
+                    if (categories.indexOf(column.category) < 0) {
+                        categories.push(column.category);
                     }
-                    if (!columns[i].operators ||
-                        (this.isLocale && this.isCustomOprCols.indexOf(columns[i].field) === -1)) {
-                        columns[i].operators = this.customOperators[columns[i].type + 'Operator'];
+                    if (!column.operators ||
+                        (this.isLocale && this.isCustomOprCols.indexOf(column.field) === -1)) {
+                        column.operators = this.customOperators[column.type + 'Operator'];
                     }
-                }
+                });
                 if (groupBy && (categories.length > 1 || categories[0] !== this.l10n.getConstant('OtherFields'))) {
                     this.fields = { text: 'label', value: 'field', groupBy: 'category' };
                 }
@@ -290,8 +324,10 @@ let QueryBuilder = class QueryBuilder extends Component {
                         isDate = value instanceof Date && !isNaN(value.getTime());
                         type = 'string';
                     }
-                    cols[i] = { 'field': columnKeys[i], 'label': columnKeys[i], 'type': isDate ? 'date' : type,
-                        'validation': validateObj };
+                    cols[i] = {
+                        'field': columnKeys[i], 'label': columnKeys[i], 'type': isDate ? 'date' : type,
+                        'validation': validateObj
+                    };
                     isDate = false;
                     cols[i].operators = this.customOperators[cols[i].type + 'Operator'];
                     if (type === 'object') {
@@ -302,8 +338,28 @@ let QueryBuilder = class QueryBuilder extends Component {
             }
         }
         else if (this.columns && this.columns.length) {
-            const columns = this.columns;
-            for (let i = 0, len = columns.length; i < len; i++) {
+            if (this.sortDirection !== 'Default') {
+                this.columnSort();
+            }
+            this.processColumnsInBatches();
+            if (this.columns.length > 50) {
+                setTimeout(() => {
+                    this.updateSubFieldsFromColumns(this.columns);
+                }, 0);
+            }
+            else {
+                this.updateSubFieldsFromColumns(this.columns);
+            }
+        }
+        this.trigger('dataBound', { type: 'dataBound' });
+    }
+    processColumnsInBatches() {
+        const columns = this.columns;
+        const batchSize = 10;
+        let processedCount = 0;
+        const processBatch = () => {
+            const endIdx = Math.min(processedCount + batchSize, columns.length);
+            for (let i = processedCount; i < endIdx; i++) {
                 if (columns[i].category && columns[i].category !== this.l10n.getConstant('OtherFields')) {
                     this.fields = { text: 'label', value: 'field', groupBy: 'category' };
                 }
@@ -316,11 +372,18 @@ let QueryBuilder = class QueryBuilder extends Component {
                     columns[i].operators = this.customOperators[columns[i].type + 'Operator'];
                 }
             }
-            this.updateSubFieldsFromColumns(this.columns);
-        }
-        this.trigger('dataBound', { type: 'dataBound' });
+            processedCount = endIdx;
+            if (processedCount < columns.length) {
+                requestAnimationFrame(processBatch);
+            }
+        };
+        processBatch();
     }
     updateSubFieldsFromColumns(col, field) {
+        if (col.length > 50) {
+            this.updateSubFieldsLarge(col, field);
+            return;
+        }
         for (let i = 0; i < col.length; i++) {
             if (this.separator !== '' && col[i].field.indexOf(this.separator) < 0) {
                 col[i].field = field ? field + this.separator + col[i].field : col[i].field;
@@ -337,6 +400,38 @@ let QueryBuilder = class QueryBuilder extends Component {
             }
         }
     }
+    updateSubFieldsLarge(col, field) {
+        let i = 0;
+        const colLength = col.length;
+        const processNextBatch = () => {
+            const endIdx = Math.min(i + 10, colLength);
+            for (; i < endIdx; i++) {
+                if (this.separator !== '' && col[i].field.indexOf(this.separator) < 0) {
+                    col[i].field = field ? field + this.separator + col[i].field : col[i].field;
+                }
+                if (col[i].operators) {
+                    this.updateCustomOperator(col[i]);
+                }
+                else if (col[i].type && col[i].type !== 'object') {
+                    col[i].operators = this.customOperators[col[i].type + 'Operator'];
+                }
+            }
+            if (i < colLength) {
+                requestAnimationFrame(processNextBatch);
+            }
+            else {
+                setTimeout(() => {
+                    for (let j = 0; j < colLength; j++) {
+                        if (col[j].columns) {
+                            col[j].type = 'object';
+                            this.updateSubFieldsFromColumns(col[j].columns, col[j].field);
+                        }
+                    }
+                }, 0);
+            }
+        };
+        processNextBatch();
+    }
     updateSubFields(value, col, data) {
         let sampCol;
         col.columns = [];
@@ -501,8 +596,10 @@ let QueryBuilder = class QueryBuilder extends Component {
                 }
                 args = { groupID: groupID, cancel: false, type: 'condition', value: targetValue.toLowerCase() };
                 if (this.enableNotCondition) {
-                    args = { groupID: groupID, cancel: false, type: 'condition', value: targetValue.toLowerCase(),
-                        'not': ariaChecked };
+                    args = {
+                        groupID: groupID, cancel: false, type: 'condition', value: targetValue.toLowerCase(),
+                        'not': ariaChecked
+                    };
                 }
             }
             if (!this.isImportRules) {
@@ -600,7 +697,7 @@ let QueryBuilder = class QueryBuilder extends Component {
     appendRuleElem(target, column, type, parentId, action, rule) {
         let ruleElem;
         let elem;
-        const ruleListElem = target.querySelector('.e-rule-list');
+        const ruleListElem = target && target.querySelector('.e-rule-list');
         let args;
         if (type === 'change') {
             ruleElem = select('#' + parentId, target);
@@ -726,23 +823,34 @@ let QueryBuilder = class QueryBuilder extends Component {
         }
     }
     addRuleSuccessCallBack(args, trgt, rule, col, act, pId, isRlTmp) {
-        const height = (this.element.className.indexOf('e-device') > -1) ? '250px' : '200px';
+        const isVertical = this.element.className.indexOf('e-device') > -1 || this.displayMode === 'Vertical';
+        const height = isVertical ? '250px' : '200px';
         let ruleID;
         const column = (rule && rule.field) ? this.getColumn(rule.field) : col ? col : this.columns[0];
         let operators;
-        let dropDownList;
         let ruleElem;
         let newRule = { 'label': '', 'field': '', 'type': '', 'operator': '' };
         if (!args.cancel) {
+            const fragment = document.createDocumentFragment();
             if (column && column.ruleTemplate && rule.field) {
                 this.selectedColumn = column;
                 operators = this.selectedColumn.operators;
-                newRule = { 'label': column.label, 'field': column.field, 'type': column.type, 'operator': operators[0].value };
+                newRule = {
+                    'label': column.label,
+                    'field': column.field,
+                    'type': column.type,
+                    'operator': operators[0].value
+                };
                 const passedRule = Object.keys(rule).length ? rule : newRule;
                 ruleElem = this.appendRuleElem(trgt, column, act, pId, 'field', passedRule);
-                const args = { requestType: 'template-create', action: 'insert-rule', ruleID: ruleElem.id,
-                    fields: this.fields, rule: passedRule };
-                this.trigger('actionBegin', args);
+                const actionArgs = {
+                    requestType: 'template-initialize',
+                    ruleID: ruleElem.id,
+                    action: 'insert-rule',
+                    fields: this.fields,
+                    rule: passedRule
+                };
+                this.trigger('actionBegin', actionArgs);
             }
             else {
                 ruleElem = this.appendRuleElem(trgt, column, act, pId, 'field');
@@ -757,139 +865,30 @@ let QueryBuilder = class QueryBuilder extends Component {
                     addClass([element], 'e-round');
                     addClass([element], 'e-icon-btn');
                     element.setAttribute('title', this.l10n.getConstant('DeleteRule'));
-                    const spanElement = this.createElement('span', { attrs: { class: 'e-btn-icon e-icons e-delete-icon' } });
-                    ruleElem.querySelector('.e-rule-delete').appendChild(spanElement);
+                    const spanElement = this.createElement('span', {
+                        attrs: { class: 'e-btn-icon e-icons e-delete-icon' }
+                    });
+                    element.appendChild(spanElement);
                 }
                 if (!this.showButtons.ruleDelete) {
                     element.classList.add('e-button-hide');
                 }
             }
-            if (this.displayMode === 'Vertical' || this.element.className.indexOf('e-device') > -1) {
-                ruleElem.className = 'e-rule-container e-vertical-mode';
-            }
-            else {
-                ruleElem.className = 'e-rule-container e-horizontal-mode';
-            }
-            let previousRuleElem = ruleElem.previousElementSibling;
-            if (this.enableSeparateConnector) {
-                let prevRule;
-                let ruleContainer;
-                if (previousRuleElem && previousRuleElem.classList.contains('e-group-container')) {
-                    ruleContainer = previousRuleElem.querySelectorAll('.e-rule-container');
-                    previousRuleElem = ruleContainer[ruleContainer.length - 1];
-                }
-                if (previousRuleElem && previousRuleElem.classList.contains('e-rule-container')) {
-                    prevRule = this.getRule(previousRuleElem);
-                }
-                if (this.headerTemplate && previousRuleElem && prevRule) {
-                    this.headerTemplateFn(previousRuleElem, false, prevRule.condition, prevRule, previousRuleElem.id);
-                }
-                else if (isNullOrUndefined(previousRuleElem) && ruleElem.id !== this.element.id + '_group0_rule0') {
-                    const group = ruleElem.closest('.e-group-container');
-                    if (group && group.previousElementSibling) {
-                        let prevElem = group.previousElementSibling;
-                        const prevRuleContainer = prevElem.querySelectorAll('.e-rule-container');
-                        if (prevElem.classList.contains('e-group-container')) {
-                            prevElem = prevRuleContainer[prevRuleContainer.length - 1];
-                        }
-                        if (prevElem.classList.contains('e-rule-container')) {
-                            const prevRule = this.getRule(prevElem);
-                            this.headerTemplateFn(prevElem, false, prevRule.condition, prevRule, prevElem.id, true);
-                        }
-                    }
-                    else {
-                        this.headerTemplateFn(ruleElem, false, rule.condition, rule, ruleElem.id, true);
-                    }
-                }
-            }
-            else {
-                if (previousRuleElem && previousRuleElem.className.indexOf('e-rule-container') > -1) {
-                    if (ruleElem.className.indexOf('e-joined-rule') < 0) {
-                        ruleElem.className += ' e-joined-rule';
-                    }
-                    if (previousRuleElem.className.indexOf('e-prev-joined-rule') < 0) {
-                        previousRuleElem.className += ' e-prev-joined-rule';
-                    }
-                }
-            }
-            if (previousRuleElem && previousRuleElem.className.indexOf('e-group-container') > -1 &&
-                ruleElem.className.indexOf('e-separate-rule') < 0) {
-                ruleElem.className += ' e-separate-rule';
-            }
+            ruleElem.className = 'e-rule-container ' + (isVertical ? 'e-vertical-mode' : 'e-horizontal-mode');
+            const previousRuleElem = ruleElem.previousElementSibling;
+            this.processAdjacentElements(ruleElem, previousRuleElem, rule);
             if (!this.isImportRules) {
                 this.updateAddedRule(trgt, rule, newRule, isRlTmp, pId, this.enableSeparateConnector ? true : null);
             }
+            const ruleCount = this.rule.rules.length;
             if (!column || (column && !column.ruleTemplate) || !rule.field) {
-                if (this.fieldMode === 'Default') {
-                    let ddlField;
-                    let ddlValue;
-                    if (this.separator && rule.field) {
-                        ddlValue = this.GetRootColumnName(rule.field);
-                    }
-                    else if (this.autoSelectField) {
-                        ddlValue = this.GetRootColumnName(rule.field);
-                    }
-                    else {
-                        ddlValue = this.isImportRules ? this.GetRootColumnName(rule.field) : rule.field;
-                    }
-                    ddlField = {
-                        dataSource: this.columns,
-                        fields: this.fields, placeholder: this.l10n.getConstant('SelectField'),
-                        popupHeight: ((this.columns.length > 5) ? height : 'auto'), close: this.fieldClose.bind(this, ruleElem.id + '_filterkey'),
-                        change: this.changeField.bind(this), value: rule ? ddlValue : null, open: this.popupOpen.bind(this, true), cssClass: 'qb-dropdownlist'
-                    };
-                    if (this.fieldModel) {
-                        ddlField = Object.assign({}, ddlField, this.fieldModel);
-                    }
-                    dropDownList = new DropDownList(ddlField);
-                    dropDownList.appendTo('#' + ruleElem.id + '_filterkey');
-                    let ddlVal;
-                    if (this.separator && rule.field) {
-                        ddlVal = this.GetRootColumnName(rule.field);
-                    }
-                    else {
-                        ddlVal = this.isImportRules ? this.GetRootColumnName(rule.field) :
-                            dropDownList.value;
-                    }
-                    this.selectedColumn = dropDownList.getDataByValue(ddlVal);
-                    if (Object.keys(rule).length) {
-                        this.changeRule(rule, {
-                            element: dropDownList.element, itemData: this.selectedColumn
-                        });
-                    }
+                if (ruleCount > 20) {
+                    setTimeout(() => {
+                        this.applyFieldComponent(ruleElem, rule, height);
+                    }, 0);
                 }
                 else {
-                    let ddlField;
-                    const ddlValue = this.isImportRules ? rule.field : rule.field;
-                    this.dummyDropdownTreeDs = extend([], this.columns, [], true);
-                    this.updateDropdowntreeDS(this.dummyDropdownTreeDs);
-                    ddlField = {
-                        fields: { dataSource: this.dummyDropdownTreeDs,
-                            value: 'field', text: 'label', child: 'columns', expanded: 'expanded', selectable: 'selectable' },
-                        placeholder: this.l10n.getConstant('SelectField'), showClearButton: false,
-                        popupHeight: ((this.columns.length > 5) ? height : 'auto'), changeOnBlur: false,
-                        change: this.changeField.bind(this), value: !isNullOrUndefined(ddlValue) ? [ddlValue] : null,
-                        open: this.popupOpen.bind(this, false), treeSettings: { expandOn: 'Click' },
-                        cssClass: 'e-qb-ddt', filtering: this.dropdownTreeFiltering.bind(this), close: this.dropdownTreeClose.bind(this)
-                    };
-                    if (this.fieldModel) {
-                        ddlField = Object.assign({}, ddlField, this.fieldModel);
-                    }
-                    const dropdowntree = new DropDownTree(ddlField);
-                    dropdowntree.appendTo('#' + ruleElem.id + '_filterkey');
-                    if (!isNullOrUndefined(dropdowntree.value)) {
-                        const value = this.getLabelFromColumn(dropdowntree.value[0]);
-                        dropdowntree.element.value = value;
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const ddlVal = !isNullOrUndefined(rule.field) ?
-                        this.GetRootColumnName(rule.field) : dropdowntree.value;
-                    this.selectedColumn = this.getColumn(ddlVal);
-                    if (Object.keys(rule).length) {
-                        this.changeRule(rule, {
-                            element: dropdowntree.element, itemData: this.selectedColumn
-                        });
-                    }
+                    this.applyFieldComponent(ruleElem, rule, height);
                 }
             }
             ruleID = ruleElem.id.replace(this.element.id + '_', '');
@@ -898,46 +897,204 @@ let QueryBuilder = class QueryBuilder extends Component {
                 this.ruleLock(lockRuleTarget);
             }
             if (!this.isImportRules && !this.prvtEvtTgrDaD) {
-                this.trigger('change', { groupID: trgt.id.replace(this.element.id + '_', ''), ruleID: ruleID, type: 'insertRule' });
+                this.trigger('change', {
+                    groupID: trgt.id.replace(this.element.id + '_', ''),
+                    ruleID: ruleID,
+                    type: 'insertRule'
+                });
             }
         }
         if (this.enableSeparateConnector && isNullOrUndefined(rule.condition) && ruleID) {
             rule = this.getRule(ruleID);
         }
         if (this.enableSeparateConnector) {
-            let prevElem = ruleElem.previousElementSibling;
-            let ruleContainer;
-            while (prevElem && !prevElem.classList.contains('e-rule-container')) {
-                if (prevElem.classList.contains('e-group-container')) {
-                    ruleContainer = prevElem.querySelectorAll('.e-rule-container');
-                    prevElem = ruleContainer[ruleContainer.length - 1];
-                    break;
+            this.processConnectorElements(ruleElem);
+        }
+    }
+    processAdjacentElements(ruleElem, previousRuleElem, rule) {
+        if (this.enableSeparateConnector) {
+            if (previousRuleElem && previousRuleElem.classList.contains('e-group-container')) {
+                const ruleContainer = previousRuleElem.querySelectorAll('.e-rule-container');
+                previousRuleElem = ruleContainer[ruleContainer.length - 1];
+            }
+            if (previousRuleElem && previousRuleElem.classList.contains('e-rule-container')) {
+                const prevRule = this.getRule(previousRuleElem);
+                if (this.headerTemplate) {
+                    this.headerTemplateFn(previousRuleElem, false, prevRule.condition, prevRule, previousRuleElem.id);
                 }
-                prevElem = prevElem.previousElementSibling;
             }
-            if (this.headerTemplate && prevElem) {
+            else if (isNullOrUndefined(previousRuleElem) && ruleElem.id !== this.element.id + '_group0_rule0') {
+                this.handleOrphanedRuleElement(ruleElem, rule);
+            }
+        }
+        else {
+            if (previousRuleElem && previousRuleElem.className.indexOf('e-rule-container') > -1) {
+                ruleElem.classList.add('e-joined-rule');
+                previousRuleElem.classList.add('e-prev-joined-rule');
+            }
+        }
+        if (previousRuleElem && previousRuleElem.className.indexOf('e-group-container') > -1 &&
+            ruleElem.className.indexOf('e-separate-rule') < 0) {
+            ruleElem.className += ' e-separate-rule';
+        }
+    }
+    handleOrphanedRuleElement(ruleElem, rule) {
+        const group = ruleElem.closest('.e-group-container');
+        if (group && group.previousElementSibling) {
+            let prevElem = group.previousElementSibling;
+            const prevRuleContainer = prevElem.querySelectorAll('.e-rule-container');
+            if (prevElem.classList.contains('e-group-container')) {
+                prevElem = prevRuleContainer[prevRuleContainer.length - 1];
+            }
+            if (prevElem.classList.contains('e-rule-container')) {
                 const prevRule = this.getRule(prevElem);
-                const args = { requestType: 'rule-template-create', ruleID: prevElem.id, condition: prevRule.condition,
-                    notCondition: this.enableNotCondition ? true : undefined };
-                this.trigger('actionBegin', args);
+                this.headerTemplateFn(prevElem, false, prevRule.condition, prevRule, prevElem.id, true);
             }
-            else if (isNullOrUndefined(prevElem) && ruleElem.id !== this.element.id + '_group0_rule0') {
-                const group = ruleElem.closest('.e-group-container');
-                if (group && group.previousElementSibling && group.previousElementSibling.previousElementSibling) {
-                    let prevElem = group.previousElementSibling.previousElementSibling;
-                    if (prevElem.classList.contains('e-group-container')) {
-                        const ruleContainer = prevElem.querySelectorAll('.e-rule-container');
-                        prevElem = ruleContainer[ruleContainer.length - 1];
-                    }
-                    if (prevElem.classList.contains('e-rule-container')) {
-                        const prevRule = this.getRule(prevElem);
-                        const args = { requestType: 'rule-template-create', ruleID: prevElem.id,
-                            condition: prevRule.condition, notCondition: this.enableNotCondition ? true : undefined };
-                        this.trigger('actionBegin', args);
-                    }
-                }
+        }
+        else {
+            this.headerTemplateFn(ruleElem, false, rule.condition, rule, ruleElem.id, true);
+        }
+    }
+    processConnectorElements(ruleElem) {
+        let prevElem = ruleElem.previousElementSibling;
+        let ruleContainer;
+        while (prevElem && !prevElem.classList.contains('e-rule-container')) {
+            if (prevElem.classList.contains('e-group-container')) {
+                ruleContainer = prevElem.querySelectorAll('.e-rule-container');
+                prevElem = ruleContainer[ruleContainer.length - 1];
+                break;
+            }
+            prevElem = prevElem.previousElementSibling;
+        }
+        if (this.headerTemplate && prevElem) {
+            const prevRule = this.getRule(prevElem);
+            const args = {
+                requestType: 'rule-template-create',
+                ruleID: prevElem.id,
+                condition: prevRule.condition,
+                notCondition: this.enableNotCondition ? true : undefined
+            };
+            this.trigger('actionBegin', args);
+        }
+        else if (isNullOrUndefined(prevElem) && ruleElem.id !== this.element.id + '_group0_rule0') {
+            this.handleOrphanedConnectorElement(ruleElem);
+        }
+        this.setMultiConnector(ruleElem);
+    }
+    handleOrphanedConnectorElement(ruleElem) {
+        const group = ruleElem.closest('.e-group-container');
+        if (group && group.previousElementSibling && group.previousElementSibling.previousElementSibling) {
+            let prevElem = group.previousElementSibling.previousElementSibling;
+            if (prevElem.classList.contains('e-group-container')) {
+                const ruleContainer = prevElem.querySelectorAll('.e-rule-container');
+                prevElem = ruleContainer[ruleContainer.length - 1];
+            }
+            if (prevElem.classList.contains('e-rule-container')) {
+                const prevRule = this.getRule(prevElem);
+                const args = {
+                    requestType: 'rule-template-create',
+                    ruleID: prevElem.id,
+                    condition: prevRule.condition,
+                    notCondition: this.enableNotCondition ? true : undefined
+                };
+                this.trigger('actionBegin', args);
             }
-            this.setMultiConnector(ruleElem);
+        }
+    }
+    applyFieldComponent(ruleElem, rule, height) {
+        if (this.fieldMode === 'Default') {
+            this.applyDropdownListComponent(ruleElem, rule, height);
+        }
+        else {
+            this.applyDropdownTreeComponent(ruleElem, rule, height);
+        }
+    }
+    applyDropdownListComponent(ruleElem, rule, height) {
+        let ddlField;
+        let ddlValue;
+        if (this.separator && rule.field) {
+            ddlValue = this.GetRootColumnName(rule.field);
+        }
+        else if (this.autoSelectField) {
+            ddlValue = this.GetRootColumnName(rule.field);
+        }
+        else {
+            ddlValue = this.isImportRules ? this.GetRootColumnName(rule.field) : rule.field;
+        }
+        ddlField = {
+            dataSource: this.columns,
+            fields: this.fields,
+            placeholder: this.l10n.getConstant('SelectField'),
+            popupHeight: ((this.columns.length > 5) ? height : 'auto'),
+            close: this.fieldClose.bind(this, ruleElem.id + '_filterkey'),
+            change: this.changeField.bind(this),
+            value: rule ? ddlValue : null,
+            open: this.popupOpen.bind(this, true),
+            cssClass: 'qb-dropdownlist'
+        };
+        if (this.fieldModel) {
+            ddlField = Object.assign({}, ddlField, this.fieldModel);
+        }
+        const dropDownList = new DropDownList(ddlField);
+        dropDownList.appendTo('#' + ruleElem.id + '_filterkey');
+        let ddlVal;
+        if (this.separator && rule.field) {
+            ddlVal = this.GetRootColumnName(rule.field);
+        }
+        else {
+            ddlVal = this.isImportRules ? this.GetRootColumnName(rule.field) : dropDownList.value;
+        }
+        this.selectedColumn = dropDownList.getDataByValue(ddlVal);
+        if (Object.keys(rule).length) {
+            this.changeRule(rule, {
+                element: dropDownList.element,
+                itemData: this.selectedColumn
+            });
+        }
+    }
+    applyDropdownTreeComponent(ruleElem, rule, height) {
+        let ddlField;
+        const ddlValue = this.isImportRules ? rule.field : rule.field;
+        this.dummyDropdownTreeDs = extend([], this.columns, [], true);
+        this.updateDropdowntreeDS(this.dummyDropdownTreeDs);
+        ddlField = {
+            fields: {
+                dataSource: this.dummyDropdownTreeDs,
+                value: 'field',
+                text: 'label',
+                child: 'columns',
+                expanded: 'expanded',
+                selectable: 'selectable'
+            },
+            placeholder: this.l10n.getConstant('SelectField'),
+            showClearButton: false,
+            popupHeight: ((this.columns.length > 5) ? height : 'auto'),
+            changeOnBlur: false,
+            change: this.changeField.bind(this),
+            value: !isNullOrUndefined(ddlValue) ? [ddlValue] : null,
+            open: this.popupOpen.bind(this, false),
+            treeSettings: { expandOn: 'Click' },
+            cssClass: 'e-qb-ddt',
+            filtering: this.dropdownTreeFiltering.bind(this),
+            close: this.dropdownTreeClose.bind(this)
+        };
+        if (this.fieldModel) {
+            ddlField = Object.assign({}, ddlField, this.fieldModel);
+        }
+        const dropdowntree = new DropDownTree(ddlField);
+        dropdowntree.appendTo('#' + ruleElem.id + '_filterkey');
+        if (!isNullOrUndefined(dropdowntree.value)) {
+            const value = this.getLabelFromColumn(dropdowntree.value[0]);
+            dropdowntree.element.value = value;
+        }
+        const ddlVal = !isNullOrUndefined(rule.field) ?
+            this.GetRootColumnName(rule.field) : dropdowntree.value;
+        this.selectedColumn = this.getColumn(ddlVal);
+        if (Object.keys(rule).length) {
+            this.changeRule(rule, {
+                element: dropdowntree.element,
+                itemData: this.selectedColumn
+            });
         }
     }
     dropdownTreeFiltering(args) {
@@ -951,7 +1108,6 @@ let QueryBuilder = class QueryBuilder extends Component {
         const ruleElem = document.getElementById(ruleElemID);
         this.ddTree = getComponent(ruleElem.querySelector('input.e-dropdowntree'), 'dropdowntree');
         const hierarchicalData = extend([], this.columns, [], true);
-        // Cancel the default filtering.
         args.cancel = true;
         if (args.text === '') {
             this.changeDataSource(hierarchicalData);
@@ -1110,7 +1266,8 @@ let QueryBuilder = class QueryBuilder extends Component {
         }
     }
     renderToolTip(element) {
-        const tooltip = new Tooltip({ content: this.l10n.getConstant('ValidationMessage'), isSticky: true,
+        const tooltip = new Tooltip({
+            content: this.l10n.getConstant('ValidationMessage'), isSticky: true,
             position: 'BottomCenter', cssClass: 'e-querybuilder-error', afterClose: () => {
                 tooltip.destroy();
             }, beforeOpen: (args) => {
@@ -1118,7 +1275,8 @@ let QueryBuilder = class QueryBuilder extends Component {
                 if (tooltipCloseElement) {
                     tooltipCloseElement.style.display = 'none';
                 }
-            } });
+            }
+        });
         tooltip.appendTo(element);
         tooltip.open(element);
     }
@@ -1276,7 +1434,6 @@ let QueryBuilder = class QueryBuilder extends Component {
         groupElem.appendChild(groupHdrElem);
         grpBodyElem.appendChild(rulesElem);
         groupElem.appendChild(grpBodyElem);
-        // create button group in OR and AND process
         if (!this.headerTemplate) {
             if (this.allowDragAndDrop) {
                 dragClsName = 'e-icons e-drag-qb-rule';
@@ -1284,8 +1441,12 @@ let QueryBuilder = class QueryBuilder extends Component {
             else {
                 dragClsName = 'e-icons e-drag-qb-rule e-hidden';
             }
-            const spanDragElement = this.createElement('span', { attrs: { class: dragClsName, 'aria-label': 'drag handle',
-                    title: 'drag handle' } });
+            const spanDragElement = this.createElement('span', {
+                attrs: {
+                    class: dragClsName, 'aria-label': 'drag handle',
+                    title: 'drag handle'
+                }
+            });
             groupHdrElem.appendChild(spanDragElement);
             const className = this.enableSeparateConnector && !isConnector ? 'e-lib e-btn-group e-qb-toggle-btn' : 'e-lib e-btn-group';
             glueElem = this.createElement('div', { attrs: { class: className, role: 'group' } });
@@ -1303,13 +1464,17 @@ let QueryBuilder = class QueryBuilder extends Component {
             }
             inputElem = this.createElement('input', { attrs: { type: 'radio', class: 'e-btngroup-and', value: 'AND' } });
             glueElem.appendChild(inputElem);
-            labelElem = this.createElement('label', { attrs: { class: 'e-lib e-btn e-btngroup-and-lbl e-small' },
-                innerHTML: this.l10n.getConstant('AND') });
+            labelElem = this.createElement('label', {
+                attrs: { class: 'e-lib e-btn e-btngroup-and-lbl e-small' },
+                innerHTML: this.l10n.getConstant('AND')
+            });
             glueElem.appendChild(labelElem);
             inputElem = this.createElement('input', { attrs: { type: 'radio', class: 'e-btngroup-or', value: 'OR' } });
             glueElem.appendChild(inputElem);
-            labelElem = this.createElement('label', { attrs: { class: 'e-lib e-btn e-btngroup-or-lbl e-small' },
-                innerHTML: this.l10n.getConstant('OR') });
+            labelElem = this.createElement('label', {
+                attrs: { class: 'e-lib e-btn e-btngroup-or-lbl e-small' },
+                innerHTML: this.l10n.getConstant('OR')
+            });
             glueElem.appendChild(labelElem);
             groupHdrElem.appendChild(glueElem);
             grpActElem = this.createElement('div', { attrs: { class: 'e-group-action' } });
@@ -1342,8 +1507,12 @@ let QueryBuilder = class QueryBuilder extends Component {
         else {
             dragClsName = 'e-icons e-drag-qb-rule e-hidden';
         }
-        const spanDragElement = this.createElement('span', { attrs: { class: dragClsName, 'aria-label': 'drag handle',
-                title: 'drag handle' } });
+        const spanDragElement = this.createElement('span', {
+            attrs: {
+                class: dragClsName, 'aria-label': 'drag handle',
+                title: 'drag handle'
+            }
+        });
         fieldElem.appendChild(spanDragElement);
         const filterElem = this.createElement('input', { attrs: { type: 'text', class: 'e-filter-input' } });
         tempElem.appendChild(filterElem);
@@ -1622,8 +1791,10 @@ let QueryBuilder = class QueryBuilder extends Component {
             }
             this.updatedRule = null;
             if (this.headerTemplate) {
-                const args = { requestType: 'header-template-create', ruleID: groupElem.id, condition: condition,
-                    notCondition: this.enableNotCondition ? not : undefined };
+                const args = {
+                    requestType: 'header-template-create', ruleID: groupElem.id, condition: condition,
+                    notCondition: this.enableNotCondition ? not : undefined
+                };
                 this.trigger('actionBegin', args);
             }
             else {
@@ -1662,9 +1833,10 @@ let QueryBuilder = class QueryBuilder extends Component {
         }
     }
     setMultiConnector(trgt) {
-        if (this.enableSeparateConnector && !this.headerTemplate) {
-            if (trgt.previousElementSibling && this.groupElem.querySelector('.e-btn-group')) {
-                trgt.parentElement.insertBefore(this.groupTemplate(true).querySelector('.e-btn-group'), trgt);
+        if (this.enableSeparateConnector && !this.headerTemplate && trgt.previousElementSibling) {
+            const btnGroupElem = this.groupTemplate(true).querySelector('.e-btn-group');
+            if (btnGroupElem) {
+                trgt.parentElement.insertBefore(btnGroupElem, trgt);
                 const notElem = trgt.previousElementSibling.childNodes[0];
                 if (notElem.classList.contains('e-qb-toggle')) {
                     notElem.style.display = 'none';
@@ -1707,9 +1879,11 @@ let QueryBuilder = class QueryBuilder extends Component {
             groupHdr = groupElem;
         }
         if (this.headerTemplate) {
-            args = { requestType: 'header-template-initialize', ruleID: groupElem.id,
+            args = {
+                requestType: 'header-template-initialize', ruleID: groupElem.id,
                 notCondition: this.enableNotCondition ? not : undefined,
-                condition: condition, rule: this.getRuleCollection(rule, false), groupID: groupID };
+                condition: condition, rule: this.getRuleCollection(rule, false), groupID: groupID
+            };
             this.trigger('actionBegin', args);
             if (this.enableSeparateConnector && groupElem.id.indexOf('rule') !== -1) {
                 args.requestType = 'rule-template-create';
@@ -1862,7 +2036,7 @@ let QueryBuilder = class QueryBuilder extends Component {
     templateChange(element, value, type) {
         const grpElem = closest(element, '.e-group-container');
         let eventsArgs;
-        const rules = this.getParentGroup(grpElem);
+        const rules = grpElem && this.getParentGroup(grpElem);
         let ruleElem = closest(element, '.e-rule-container');
         let index = 0;
         if (this.allowValidation) {
@@ -1877,7 +2051,7 @@ let QueryBuilder = class QueryBuilder extends Component {
                 index++;
             }
         }
-        const rule = rules.rules[index];
+        const rule = rules && rules.rules[index];
         if (type === 'field') {
             this.selectedColumn = this.getColumn(value);
         }
@@ -1885,7 +2059,7 @@ let QueryBuilder = class QueryBuilder extends Component {
             this.selectedColumn = this.getColumn(rule.field);
         }
         let operVal;
-        this.previousColumn = this.getColumn(rule.field);
+        this.previousColumn = rule && this.getColumn(rule.field);
         const beforeRules = this.getValidRules(this.rule);
         if (this.selectedColumn) {
             if (this.selectedColumn.operators) {
@@ -1900,11 +2074,16 @@ let QueryBuilder = class QueryBuilder extends Component {
         switch (type) {
             case 'field':
                 if (isNullOrUndefined(value)) {
-                    rule.field = '';
-                    rule.label = '';
-                    rule.type = '';
-                    rule.value = '';
-                    rule.operator = '';
+                    if (!isNullOrUndefined(rule)) {
+                        rule.field = '';
+                        rule.label = '';
+                        rule.type = '';
+                        rule.value = '';
+                        rule.operator = '';
+                    }
+                    else {
+                        return;
+                    }
                 }
                 else {
                     rule.field = value;
@@ -1955,10 +2134,14 @@ let QueryBuilder = class QueryBuilder extends Component {
                     ruleElement.className.indexOf('e-separate-rule') < 0) {
                     ruleElement.className += ' e-separate-rule';
                 }
-                const args = { requestType: 'template-create', action: type, ruleID: grpEle.id,
-                    fields: this.fields, rule: rule };
-                eventsArgs = { groupID: grpElem.id.replace(this.element.id + '_', ''), ruleID: grpEle.id.replace(this.element.id + '_', ''),
-                    value: rule.field, type: 'field' };
+                const args = {
+                    requestType: 'template-create', action: type, ruleID: grpEle.id,
+                    fields: this.fields, rule: rule
+                };
+                eventsArgs = {
+                    groupID: grpElem.id.replace(this.element.id + '_', ''), ruleID: grpEle.id.replace(this.element.id + '_', ''),
+                    value: rule.field, type: 'field'
+                };
                 this.trigger('actionBegin', args);
                 this.trigger('change', eventsArgs);
             }
@@ -2097,8 +2280,10 @@ let QueryBuilder = class QueryBuilder extends Component {
         const item = ddl.popupObj && ddl.popupObj.element.querySelector('.e-active');
         const itemData = ddl.getItemData();
         ddl.value = itemData.value;
-        const customArgs = { element: ddl.element, value: itemData.value, isInteracted: true,
-            previousItemData: this.prevItemData, previousItem: null, item: item, itemData: itemData, event: null, e: null };
+        const customArgs = {
+            element: ddl.element, value: itemData.value, isInteracted: true,
+            previousItemData: this.prevItemData, previousItem: null, item: item, itemData: itemData, event: null, e: null
+        };
         if (ddl.previousValue !== ddl.value) {
             this.changeField(customArgs);
         }
@@ -2210,8 +2395,10 @@ let QueryBuilder = class QueryBuilder extends Component {
             this.selectedColumn = this.getColumn(ddlValue);
             const ruleElem = closest(flt, '.e-rule-container');
             const ruleID = ruleElem.id.replace(this.element.id + '_', '');
-            const eventsArgs = { groupID: grID, ruleID: ruleID, selectedField: this.fieldMode === 'DropdownTree' ?
-                    dl.value[0] : dl.value, cancel: false, type: 'field' };
+            const eventsArgs = {
+                groupID: grID, ruleID: ruleID, selectedField: this.fieldMode === 'DropdownTree' ?
+                    dl.value[0] : dl.value, cancel: false, type: 'field'
+            };
             if (!this.isImportRules && !this.prvtEvtTgrDaD) {
                 this.trigger('beforeChange', eventsArgs, (observedChangeArgs) => {
                     this.fieldChangeSuccess(observedChangeArgs, tmpRl, flt, rl, dArg);
@@ -2794,19 +2981,25 @@ let QueryBuilder = class QueryBuilder extends Component {
             : getComponent(container.querySelector('.e-rule-filter .e-filter-input'), 'dropdownlist');
         const column = this.fieldMode === 'DropdownTree' ? this.getColumn(ddlObj.value[0]) : this.getColumn(ddlObj.value);
         if (typeof itemData.template === 'string' || itemData.template.write === undefined) {
-            const args = { rule: rule, ruleID: container.id, operator: tempRule.operator, field: column.field,
-                requestType: 'value-template-create' };
+            const args = {
+                rule: rule, ruleID: container.id, operator: tempRule.operator, field: column.field,
+                requestType: 'value-template-create'
+            };
             this.trigger('actionBegin', args);
         }
         else {
             const template = itemData.template;
             if (typeof template.write === 'string') {
-                getValue(template.write, window)({ elements: tempElements.length > 1 ? tempElements : tempElements[0], values: rule.value,
-                    operator: tempRule.operator, field: column.field, dataSource: column.values });
+                getValue(template.write, window)({
+                    elements: tempElements.length > 1 ? tempElements : tempElements[0], values: rule.value,
+                    operator: tempRule.operator, field: column.field, dataSource: column.values
+                });
             }
             else if (typeof itemData.template !== 'function') {
-                itemData.template.write({ elements: tempElements.length > 1 ? tempElements : tempElements[0],
-                    values: rule.value, operator: tempRule.operator, field: column.field, dataSource: column.values });
+                itemData.template.write({
+                    elements: tempElements.length > 1 ? tempElements : tempElements[0],
+                    values: rule.value, operator: tempRule.operator, field: column.field, dataSource: column.values
+                });
             }
         }
     }
@@ -3303,8 +3496,10 @@ let QueryBuilder = class QueryBuilder extends Component {
         }
         else {
             if (typeof itemData.template === 'string' || itemData.template.create === undefined) {
-                args = { requestType: 'value-template-initialize', ruleID: ruleID, field: field, operator: operator, rule: rule,
-                    renderTemplate: true };
+                args = {
+                    requestType: 'value-template-initialize', ruleID: ruleID, field: field, operator: operator, rule: rule,
+                    renderTemplate: true
+                };
                 this.trigger('actionBegin', args, (observedActionArgs) => {
                     isRendered = this.actionBeginSuccessCallBack(observedActionArgs, itemData, ruleID, field, target);
                 });
@@ -3512,7 +3707,6 @@ let QueryBuilder = class QueryBuilder extends Component {
             element = element ? element : ruleElement.nextElementSibling.nextElementSibling.querySelector('input.e-control');
             operator = getComponent(element, 'dropdownlist').value.toString();
             rule.rules[index].operator = operator;
-            // Value Fields
             const valueContainer = ruleElement.nextElementSibling.nextElementSibling;
             let elementCln = valueContainer.querySelectorAll('input.e-control');
             if (elementCln.length < 1) {
@@ -3674,6 +3868,9 @@ let QueryBuilder = class QueryBuilder extends Component {
         }
     }
     validateValue(rule, ruleElem, index) {
+        if (isNullOrUndefined(rule) && isNullOrUndefined(ruleElem)) {
+            return;
+        }
         if (!isNullOrUndefined(index)) {
             rule = rule.rules[index];
         }
@@ -3835,8 +4032,10 @@ let QueryBuilder = class QueryBuilder extends Component {
             if (grouplen) {
                 this.isPublic = true;
                 for (let i = 0, len = groups.length; i < len; i++) {
-                    this.updatedRule = { isLocked: groups[i].isLocked, condition: groups[i].condition,
-                        not: groups[i].not };
+                    this.updatedRule = {
+                        isLocked: groups[i].isLocked, condition: groups[i].condition,
+                        not: groups[i].not
+                    };
                     this.importRules(groups[i], groupElem, false, groups[i].not);
                 }
                 this.isPublic = false;
@@ -3965,10 +4164,10 @@ let QueryBuilder = class QueryBuilder extends Component {
         this.element.querySelector('.e-group-header').appendChild(collapseElem);
     }
     columnSort() {
-        if (this.sortDirection.toLowerCase() === 'descending') {
+        if (this.sortDirection && this.sortDirection.toLowerCase() === 'descending') {
             this.columns = new DataManager(this.columns).executeLocal(new Query().sortByDesc('field'));
         }
-        else if (this.sortDirection.toLowerCase() === 'ascending') {
+        else if (this.sortDirection && this.sortDirection.toLowerCase() === 'ascending') {
             this.columns = new DataManager(this.columns).executeLocal(new Query().sortBy('field'));
         }
     }
@@ -4454,8 +4653,10 @@ let QueryBuilder = class QueryBuilder extends Component {
                 }
             }
         }
-        const dragEventArgs = { dragRuleID: targetElem !== null ? targetElem.id : grpElem !== null ? grpElem.id : null,
-            dragGroupID: grpElem !== null ? grpElem.id : null, cancel: false };
+        const dragEventArgs = {
+            dragRuleID: targetElem !== null ? targetElem.id : grpElem !== null ? grpElem.id : null,
+            dragGroupID: grpElem !== null ? grpElem.id : null, cancel: false
+        };
         this.trigger('drag', dragEventArgs);
         this.isDragEventPrevent = dragEventArgs.cancel;
     }
@@ -4475,8 +4676,10 @@ let QueryBuilder = class QueryBuilder extends Component {
         let prevRule;
         if (!isPreventelem) {
             const targetGrp = closest(e.target, '.e-group-container');
-            const dropEventArgs = { cancel: false, dropRuleID: targetGroup !== null ? targetGroup.id
-                    : targetGrp !== null ? targetGrp.id : null, dropGroupID: targetGrp !== null ? targetGrp.id : null };
+            const dropEventArgs = {
+                cancel: false, dropRuleID: targetGroup !== null ? targetGroup.id
+                    : targetGrp !== null ? targetGrp.id : null, dropGroupID: targetGrp !== null ? targetGrp.id : null
+            };
             this.trigger('drop', dropEventArgs);
             if (dropEventArgs.cancel) {
                 isPreventelem = true;
@@ -5242,7 +5445,8 @@ let QueryBuilder = class QueryBuilder extends Component {
         else {
             if (customObj && (customObj.type === 'question' || customObj.type === 'answer')) {
                 const notValue = rule.not;
-                rule = { 'label': rule.label, 'field': rule.field, 'operator': rule.operator, 'type': rule.type, 'value': rule.value,
+                rule = {
+                    'label': rule.label, 'field': rule.field, 'operator': rule.operator, 'type': rule.type, 'value': rule.value,
                     'condition': rule.condition, 'rules': rule.rules
                 };
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -5564,21 +5768,40 @@ let QueryBuilder = class QueryBuilder extends Component {
         let columns = this.columns;
         let column;
         columns = col ? col : columns;
-        for (let i = 0, iLen = columns.length; i < iLen; i++) {
+        const fieldParts = this.separator !== '' ? (field ? field.split(this.separator) : []) : [field];
+        const rootField = fieldParts && fieldParts.length > 0 ? fieldParts[0] : null;
+        for (let i = 0; i < columns.length; i++) {
             if (columns[i].field === field) {
                 column = columns[i];
                 break;
             }
-            else if (columns[i].columns) {
-                column = this.getColumn(field, columns[i].columns);
-                if (column) {
+        }
+        if (!column && this.separator !== '') {
+            for (let i = 0; i < columns.length; i++) {
+                if (columns[i].field === rootField) {
+                    if (columns[i].columns) {
+                        const subField = field.substring(rootField.length + this.separator.length);
+                        if (subField) {
+                            column = this.getColumn(subField, columns[i].columns);
+                        }
+                        else {
+                            column = columns[i];
+                        }
+                    }
+                    else {
+                        column = columns[i];
+                    }
                     break;
                 }
             }
-            else if (field && field.indexOf(this.separator) > -1) {
-                if (this.separator !== '' && columns[i].field === field.split(this.separator)[0]) {
-                    column = columns[i];
-                    break;
+        }
+        if (!column) {
+            for (let i = 0; i < columns.length; i++) {
+                if (columns[i].columns) {
+                    column = this.getColumn(field, columns[i].columns);
+                    if (column) {
+                        break;
+                    }
                 }
             }
         }
@@ -6039,86 +6262,74 @@ let QueryBuilder = class QueryBuilder extends Component {
         else {
             queryStr += '(';
         }
-        let condition = rules.condition;
         if (rules.not) {
-            let rulesNotCondition;
-            if (isRoot) {
-                rulesNotCondition = sqlLocale ? this.l10n.getConstant('NOT').toUpperCase() + ' (' : 'NOT (';
-                queryStr += rulesNotCondition;
-            }
-            else {
-                rulesNotCondition = sqlLocale ? ' ' + this.l10n.getConstant('NOT').toUpperCase() + ' (' : ' NOT (';
-                queryStr += rulesNotCondition;
-            }
+            const notPrefix = sqlLocale ? this.l10n.getConstant('NOT').toUpperCase() + ' ' : 'NOT ';
+            queryStr += isRoot ? notPrefix + '(' : ' ' + notPrefix + '(';
         }
-        if (rules.rules) {
-            for (let j = 0, jLen = rules.rules.length; j < jLen; j++) {
-                if (rules.rules[j].rules) {
-                    queryStr = this.getSqlString(rules.rules[j], enableEscape, queryStr, sqlLocale);
+        if (rules.rules && rules.rules.length) {
+            queryStr += rules.rules.reduce((result, rule, j) => {
+                let ruleStr = '';
+                if (rule.rules) {
+                    ruleStr = this.getSqlString(rule, enableEscape, '', sqlLocale);
                     if (this.enableSeparateConnector) {
-                        condition = rules.rules[j].condition;
+                        rules.condition = rule.condition;
                     }
                 }
                 else {
-                    const rule = rules.rules[j];
-                    let valueStr = '';
                     const ruleOpertor = sqlLocale ? this.sqlOperators[rule.operator] : this.operators[rule.operator];
+                    let valueStr = '';
                     if (rule.value instanceof Array) {
                         if (rule.operator.toString().indexOf('between') > -1) {
-                            const ruleCondition = sqlLocale ? ' ' + this.l10n.getConstant('AND').toUpperCase() + ' ' : ' ' + 'AND' + ' ';
+                            const ruleCondition = sqlLocale ? ' ' + this.l10n.getConstant('AND').toUpperCase() + ' ' : ' AND ';
                             if (rule.type === 'date' && !this.isDateFunction(rule.value[0])) {
-                                valueStr += '"' + rule.value[0] + '"' + ruleCondition + '"' + rule.value[1] + '"';
+                                valueStr = `"${rule.value[0]}"${ruleCondition}"${rule.value[1]}"`;
                             }
                             else {
-                                valueStr += rule.value[0] + ruleCondition + rule.value[1];
+                                valueStr = `${rule.value[0]}${ruleCondition}${rule.value[1]}`;
                             }
                         }
                         else {
                             if (typeof rule.value[0] === 'string' && rule.value !== null) {
-                                valueStr += '("' + rule.value[0] + '"';
-                                for (let k = 1, kLen = rule.value.length; k < kLen; k++) {
-                                    valueStr += ',"' + rule.value[k] + '"';
-                                }
-                                valueStr += ')';
+                                const valueArray = rule.value;
+                                valueStr = '("' + valueArray.join('","') + '")';
                             }
                             else {
-                                valueStr += '(' + rule.value + ')';
+                                valueStr = `(${rule.value})`;
                             }
                         }
                     }
                     else {
                         if (rule.operator.toString().indexOf('startswith') > -1) {
-                            valueStr += rule.value ? '("' + rule.value + '%")' : '(' + rule.value + ')';
+                            valueStr = rule.value ? `("${rule.value}%")` : `(${rule.value})`;
                         }
                         else if (rule.operator.toString().indexOf('endswith') > -1) {
-                            valueStr += rule.value ? '("%' + rule.value + '")' : '(' + rule.value + ')';
+                            valueStr = rule.value ? `("%${rule.value}")` : `(${rule.value})`;
                         }
                         else if (rule.operator.toString().indexOf('contains') > -1) {
-                            valueStr += rule.value ? '("%' + rule.value + '%")' : '(' + rule.value + ')';
+                            valueStr = rule.value ? `("%${rule.value}%")` : `(${rule.value})`;
                         }
                         else {
                             if (rule.type === 'number' || typeof rule.value === 'boolean' ||
                                 (rule.value === null && (rule.operator.toString().indexOf('empty') < -1))) {
-                                valueStr += rule.value;
+                                valueStr = `${rule.value}`;
                             }
                             else if (rule.operator.toString().indexOf('empty') > -1) {
-                                valueStr += '""';
+                                valueStr = '""';
                             }
                             else {
-                                valueStr += '"' + rule.value + '"';
+                                valueStr = `"${rule.value}"`;
                             }
                         }
                     }
+                    let fieldName = rule.field;
+                    if (enableEscape) {
+                        fieldName = '`' + fieldName + '`';
+                    }
+                    else if (fieldName.indexOf(' ') > -1) {
+                        fieldName = '"' + fieldName + '"';
+                    }
                     if (rule.operator.toString().indexOf('null') > -1) {
-                        if (enableEscape) {
-                            rule.field = '`' + rule.field + '`';
-                        }
-                        else {
-                            if (rule.field.indexOf(' ') > -1) {
-                                rule.field = '"' + rule.field + '"';
-                            }
-                        }
-                        queryStr += rule.field + ' ' + ruleOpertor;
+                        ruleStr = fieldName + ' ' + ruleOpertor;
                     }
                     else {
                         let custOper = ruleOpertor;
@@ -6128,33 +6339,21 @@ let QueryBuilder = class QueryBuilder extends Component {
                         else if (rule.operator === 'isnotempty') {
                             custOper = '!=';
                         }
-                        if (enableEscape) {
-                            rule.field = '`' + rule.field + '`';
-                        }
-                        else {
-                            if (rule.field.indexOf(' ') > -1) {
-                                rule.field = '"' + rule.field + '"';
-                            }
-                        }
-                        queryStr += rule.field + ' ' + custOper + ' ' + valueStr;
-                    }
-                    if (rule.condition && rule.condition !== '') {
-                        condition = rule.condition;
+                        ruleStr = fieldName + ' ' + custOper + ' ' + valueStr;
                     }
                 }
-                if (j !== jLen - 1) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const rule = rules.rules[j];
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (j !== rules.rules.length - 1) {
+                    let condition = rules.condition;
                     if (condition === '' || (rule && rule.condition !== '' && rule.custom && rule.custom.isCustom)) {
                         condition = rule.condition;
                     }
                     if (condition) {
                         condition = sqlLocale ? this.l10n.getConstant(condition.toUpperCase()).toUpperCase() : condition.toUpperCase();
-                        queryStr += ' ' + condition + ' ';
+                        ruleStr += ' ' + condition + ' ';
                     }
                 }
-            }
+                return result + ruleStr;
+            }, '');
         }
         if (!isRoot) {
             queryStr += ')';
@@ -6472,23 +6671,19 @@ let QueryBuilder = class QueryBuilder extends Component {
                 return subOp[i].length;
             }
         }
-        //Left Parenthesis
         if (/^\(/.exec(sqlString)) {
             this.parser.push(['Left', '(']);
             return 1;
         }
-        //Right Parenthesis
         if (/^\)/.exec(sqlString)) {
             this.parser.push(['Right', ')']);
             return 1;
         }
-        //Boolean
         if (/^(true|false)/.exec(sqlString)) {
             matchValue = /^(true|false)/.exec(sqlString)[0];
             this.parser.push(['String', matchValue]);
             return matchValue.length;
         }
-        //Null
         if (/^null/.exec(sqlString)) {
             matchValue = /^null/.exec(sqlString)[0];
             this.parser.push(['String', null]);
@@ -6513,7 +6708,6 @@ let QueryBuilder = class QueryBuilder extends Component {
                 return matchValue.length;
             }
         }
-        //String
         const singleString = this.getSingleQuoteString(sqlString);
         if (singleString !== '') {
             matchValue = singleString;
@@ -6533,24 +6727,20 @@ let QueryBuilder = class QueryBuilder extends Component {
                 !this.checkCondition(sqlString, matchValue)) {
                 matchValue = this.combineSingleQuoteString(sqlString, matchValue);
             }
-            // end
             this.parser.push(['String', matchValue]);
             return matchValue.length;
         }
-        // Double String
         const doubleString = this.getDoubleQuoteString(sqlString);
         if (doubleString !== '') {
             matchValue = doubleString;
             this.parser.push(['DoubleString', matchValue]);
             return matchValue.length;
         }
-        //Number
         if (/^\d*\.?\d+/.exec(sqlString)) {
             matchValue = /^\d*\.?\d+/.exec(sqlString)[0];
             this.parser.push(['Number', matchValue]);
             return matchValue.length;
         }
-        //Negative Number
         if (/^-?\d*\.?\d+/.exec(sqlString)) {
             matchValue = /^-?\d*\.?\d+/.exec(sqlString)[0];
             this.parser.push(['Number', matchValue]);
@@ -6718,7 +6908,7 @@ let QueryBuilder = class QueryBuilder extends Component {
                 fieldName += this.separator;
             }
         }
-        return this.getColumn(fieldName).label;
+        return this.getColumn(fieldName) ? this.getColumn(fieldName).label : '';
     }
     processParser(parser, rules, levelColl, sqlLocale) {
         let j;
@@ -6950,12 +7140,16 @@ let QueryBuilder = class QueryBuilder extends Component {
             }
         }
         if (this.enableSeparateConnector) {
-            this.addRules([{ 'label': getRule.label, 'field': getRule.field, 'type': getRule.type, 'operator': getRule.operator,
-                    'value': getRule.value, 'condition': getRule.condition }], groupId);
+            this.addRules([{
+                    'label': getRule.label, 'field': getRule.field, 'type': getRule.type, 'operator': getRule.operator,
+                    'value': getRule.value, 'condition': getRule.condition
+                }], groupId);
         }
         else {
-            this.addRules([{ 'label': getRule.label, 'field': getRule.field, 'type': getRule.type, 'operator': getRule.operator,
-                    'value': getRule.value }], groupId);
+            this.addRules([{
+                    'label': getRule.label, 'field': getRule.field, 'type': getRule.type, 'operator': getRule.operator,
+                    'value': getRule.value
+                }], groupId);
         }
         this.ruleIndex = -1;
     }
@@ -7130,115 +7324,65 @@ let QueryBuilder = class QueryBuilder extends Component {
         this.disableRuleControls(target, groupElem, isDisabled);
     }
     disableRuleControls(target, groupElem, isDisabled) {
-        const ddlElement = groupElem.querySelectorAll('.e-control.e-dropdownlist');
-        const numericElement = groupElem.querySelectorAll('.e-control.e-numerictextbox');
-        const textElement = groupElem.querySelectorAll('.e-control.e-textbox');
-        const dateElement = groupElem.querySelectorAll('.e-control.e-datepicker');
-        const checkboxElement = groupElem.querySelectorAll('.e-control.e-checkbox');
-        const radioBtnElement = groupElem.querySelectorAll('.e-control.e-radio');
-        const multiSelectElement = groupElem.querySelectorAll('.e-control.e-multiselect');
-        const deleteElem = groupElem.querySelectorAll('.e-rule-delete');
-        const lockElem = groupElem.querySelectorAll('.e-lock-rule');
-        const cloneElem = groupElem.querySelectorAll('.e-clone-rule');
-        const ruleElem = groupElem.querySelectorAll('.e-rule-container');
-        for (let i = 0; i < deleteElem.length; i++) {
+        const disableComponents = (elements, componentGetter, isDisabled) => {
+            elements.forEach((element) => {
+                const component = componentGetter(element);
+                if ('enabled' in component) {
+                    component.enabled = !isDisabled;
+                }
+                else if ('disabled' in component) {
+                    component.disabled = isDisabled;
+                }
+            });
+        };
+        const elements = {
+            ddl: groupElem.querySelectorAll('.e-control.e-dropdownlist'),
+            numeric: groupElem.querySelectorAll('.e-control.e-numerictextbox'),
+            text: groupElem.querySelectorAll('.e-control.e-textbox'),
+            date: groupElem.querySelectorAll('.e-control.e-datepicker'),
+            checkbox: groupElem.querySelectorAll('.e-control.e-checkbox'),
+            radio: groupElem.querySelectorAll('.e-control.e-radio'),
+            multiSelect: groupElem.querySelectorAll('.e-control.e-multiselect'),
+            deleteElem: groupElem.querySelectorAll('.e-rule-delete'),
+            lockElem: groupElem.querySelectorAll('.e-lock-rule'),
+            cloneElem: groupElem.querySelectorAll('.e-clone-rule'),
+            ruleElem: groupElem.querySelectorAll('.e-rule-container')
+        };
+        elements.deleteElem.forEach((elem, i) => {
             if (isDisabled) {
-                if (ruleElem[i] && ruleElem[i].classList.contains('e-disable')) {
-                    ruleElem[i].classList.add('e-disable');
+                if (elements.ruleElem[i] && elements.ruleElem[i].classList.contains('e-disable')) {
+                    elements.ruleElem[i].classList.add('e-disable');
                 }
-                deleteElem[i].disabled = true;
-                if (cloneElem[i]) {
-                    cloneElem[i].disabled = true;
+                elements.deleteElem[i].disabled = true;
+                if (elements.cloneElem[i]) {
+                    elements.cloneElem[i].disabled = true;
                 }
-                if (lockElem[i] !== target) {
-                    lockElem[i].disabled = true;
-                    lockElem[i].children[0].classList.remove('e-unlock');
-                    lockElem[i].children[0].classList.add('e-lock');
+                if (elements.lockElem[i] !== target) {
+                    elements.lockElem[i].disabled = true;
+                    elements.lockElem[i].children[0].classList.remove('e-unlock');
+                    elements.lockElem[i].children[0].classList.add('e-lock');
                 }
             }
             else {
-                if (ruleElem[i]) {
-                    ruleElem[i].classList.remove('e-disable');
+                if (elements.ruleElem[i]) {
+                    elements.ruleElem[i].classList.remove('e-disable');
                 }
-                if (cloneElem[i]) {
-                    cloneElem[i].disabled = false;
+                if (elements.cloneElem[i]) {
+                    elements.cloneElem[i].disabled = false;
                 }
-                deleteElem[i].disabled = false;
-                lockElem[i].disabled = false;
-                lockElem[i].children[0].classList.remove('e-lock');
-                lockElem[i].children[0].classList.add('e-unlock');
-            }
-        }
-        let dropDownObj;
-        let numericObj;
-        let textObj;
-        let dateObj;
-        let checkBoxObj;
-        let radioBtnObj;
-        let multiSelectObj;
-        for (let i = 0; i < ddlElement.length; i++) {
-            dropDownObj = getComponent(ddlElement[i], 'dropdownlist');
-            if (isDisabled) {
-                dropDownObj.enabled = false;
+                elements.deleteElem[i].disabled = false;
+                elements.lockElem[i].disabled = false;
+                elements.lockElem[i].children[0].classList.remove('e-lock');
+                elements.lockElem[i].children[0].classList.add('e-unlock');
             }
-            else {
-                dropDownObj.enabled = true;
-            }
-        }
-        for (let i = 0; i < numericElement.length; i++) {
-            numericObj = getComponent(numericElement[i], 'numerictextbox');
-            if (isDisabled) {
-                numericObj.enabled = false;
-            }
-            else {
-                numericObj.enabled = true;
-            }
-        }
-        for (let i = 0; i < textElement.length; i++) {
-            textObj = getComponent(textElement[i], 'textbox');
-            if (isDisabled) {
-                textObj.enabled = false;
-            }
-            else {
-                textObj.enabled = true;
-            }
-        }
-        for (let i = 0; i < dateElement.length; i++) {
-            dateObj = getComponent(dateElement[i], 'datepicker');
-            if (isDisabled) {
-                dateObj.enabled = false;
-            }
-            else {
-                dateObj.enabled = true;
-            }
-        }
-        for (let i = 0; i < checkboxElement.length; i++) {
-            checkBoxObj = getComponent(checkboxElement[i], 'checkbox');
-            if (isDisabled) {
-                checkBoxObj.disabled = true;
-            }
-            else {
-                checkBoxObj.disabled = false;
-            }
-        }
-        for (let i = 0; i < radioBtnElement.length; i++) {
-            radioBtnObj = getComponent(radioBtnElement[i], 'radio');
-            if (isDisabled) {
-                radioBtnObj.disabled = true;
-            }
-            else {
-                radioBtnObj.disabled = false;
-            }
-        }
-        for (let i = 0; i < multiSelectElement.length; i++) {
-            multiSelectObj = getComponent(multiSelectElement[i], 'multiselect');
-            if (isDisabled) {
-                multiSelectObj.enabled = false;
-            }
-            else {
-                multiSelectObj.enabled = true;
-            }
-        }
+        });
+        disableComponents(elements.ddl, (elem) => getComponent(elem, 'dropdownlist'), isDisabled);
+        disableComponents(elements.numeric, (elem) => getComponent(elem, 'numerictextbox'), isDisabled);
+        disableComponents(elements.text, (elem) => getComponent(elem, 'textbox'), isDisabled);
+        disableComponents(elements.date, (elem) => getComponent(elem, 'datepicker'), isDisabled);
+        disableComponents(elements.checkbox, (elem) => getComponent(elem, 'checkbox'), isDisabled);
+        disableComponents(elements.radio, (elem) => getComponent(elem, 'radio'), isDisabled);
+        disableComponents(elements.multiSelect, (elem) => getComponent(elem, 'multiselect'), isDisabled);
     }
 };
 __decorate([