@datagrok-libraries/utils 4.6.2 → 4.6.4

package/src/query-builder/query-builder.js

@@ -0,0 +1,694 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+import '../../css/query-builder.css';
+import dayjs from 'dayjs';
+export const SUGGESTIONS_FUNCTION = 'suggestionsFunction';
+export var Operators;
+(function (Operators) {
+    Operators.CONTAINS = 'contains';
+    Operators.IN = 'in';
+    Operators.STARTS_WITH = 'starts with';
+    Operators.ENDS_WITH = 'ends with';
+    Operators.GT = '>';
+    Operators.GTE = '>=';
+    Operators.LT = '<';
+    Operators.LTE = '<=';
+    Operators.EQ = '=';
+    Operators.NOT_EQ = '!=';
+    Operators.BEFORE = 'before';
+    Operators.AFTER = 'after';
+    Operators.ON = 'on';
+    Operators.BETWEEN = 'between';
+    Operators.IS_SIMILAR = 'is similar';
+    Operators.IS_CONTAINED = 'is contained';
+    let Logical;
+    (function (Logical) {
+        Logical["and"] = "and";
+        Logical["or"] = "or";
+    })(Logical = Operators.Logical || (Operators.Logical = {}));
+})(Operators || (Operators = {}));
+export var QueryBuilderLayout;
+(function (QueryBuilderLayout) {
+    QueryBuilderLayout["Standard"] = "standard";
+    QueryBuilderLayout["Narrow"] = "narrow";
+})(QueryBuilderLayout || (QueryBuilderLayout = {}));
+export class BaseConditionEditor {
+    constructor(prop, operator, initialCondition) {
+        this.root = ui.div();
+        this.onChanged = new Subject();
+        this.showSuggestions = false;
+        this.suggestionsMenuClicked = false;
+        this.condition = initialCondition !== null && initialCondition !== void 0 ? initialCondition : {
+            field: prop.name,
+            operator: operator,
+            value: undefined
+        };
+        this.initializeEditor(prop);
+    }
+    initializeEditor(prop) {
+        if (Array.isArray(this.condition.value))
+            this.condition.value = undefined;
+        const initVal = prop.type === DG.TYPE.DATE_TIME && typeof this.condition.value === 'string' ?
+            dayjs(this.condition.value) : this.condition.value;
+        const input = ui.input.forProperty(prop, undefined, {
+            value: initVal,
+            nullable: false,
+            onValueChanged: () => {
+                this.condition.value = input.value;
+                this.onChanged.next(this.condition);
+                this.addSuggestions(prop, input);
+            }
+        });
+        input.addCaption('');
+        this.root.append(input.root);
+        this.initializeSuggestions(prop, input);
+    }
+    initializeSuggestions(prop, input) {
+        this.showSuggestions = prop.type === DG.TYPE.STRING && prop.options[SUGGESTIONS_FUNCTION];
+        if (this.showSuggestions) {
+            suggestionMenuKeyNavigation(this.root);
+        }
+    }
+    addSuggestions(prop, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.showSuggestions && !this.suggestionsMenuClicked) {
+                if (input.value) {
+                    const suggestions = yield prop.options[SUGGESTIONS_FUNCTION](input.value);
+                    if (suggestions.length === 1 && suggestions[0] === input.value)
+                        return;
+                    const suggestionsMenu = DG.Menu.popup();
+                    suggestions.forEach((s) => {
+                        suggestionsMenu.item(s, () => {
+                            input.value = s;
+                            this.suggestionsMenuClicked = true;
+                        });
+                    });
+                    suggestionsMenu.show({ element: input.root, y: input.root.offsetHeight });
+                }
+            }
+            this.suggestionsMenuClicked = false;
+        });
+    }
+}
+export class BetweenConditionEditor extends BaseConditionEditor {
+    initializeEditor(prop) {
+        if (!this.condition.value || !Array.isArray(this.condition.value)) {
+            this.condition.value = [this.condition.value, undefined];
+            this.onChanged.next(this.condition);
+        }
+        const input1 = ui.input.forProperty(prop, this.condition.value[0], {
+            nullable: false,
+            onValueChanged: () => {
+                this.condition.value[0] = input1.value;
+                this.onChanged.next(this.condition);
+            }
+        });
+        input1.addCaption('');
+        const input2 = ui.input.forProperty(prop, this.condition.value[1], {
+            value: this.condition.value[1],
+            onValueChanged: () => {
+                this.condition.value[1] = input2.value;
+                this.onChanged.next(this.condition);
+            }
+        });
+        input2.addCaption('');
+        this.root.append(ui.divH([input1.root, input2.root], { style: { gap: '10px' } }));
+    }
+}
+export class BooleanConditionEditor extends BaseConditionEditor {
+    initializeEditor(prop) {
+        if (!this.condition.value)
+            this.condition.value = true;
+        const options = ['true', 'false'];
+        const input = ui.input.choice('', {
+            items: options,
+            nullable: false,
+            value: this.condition.value ? 'true' : 'false',
+            onValueChanged: () => {
+                this.condition.value = input.value === 'true';
+                this.onChanged.next(this.condition);
+            }
+        });
+        this.root.append(input.root);
+    }
+}
+export class MoleculeConditionEditor extends BaseConditionEditor {
+    initializeEditor(prop) {
+        //if we swith from similarity input to standard molecule input - need to modify value
+        if (this.condition.value && typeof this.condition.value !== 'string') {
+            if ('molecule' in this.condition.value)
+                this.condition.value = this.condition.value.molecule;
+            else
+                this.condition.value = '';
+        }
+        const input = ui.input.molecule('', {
+            value: this.condition.value,
+            onValueChanged: () => {
+                this.condition.value = input.value;
+                this.onChanged.next(this.condition);
+            }
+        });
+        this.root.append(input.root);
+        //to adjust the filter width considering molecule input
+        this.root.style.paddingTop = '15px';
+        this.root.style.paddingBottom = '15px';
+    }
+}
+export class MoleculeSimilarityConditionEditor extends BaseConditionEditor {
+    initializeEditor(prop) {
+        var _a;
+        //in case we switch from some other operator, where value is a string (contains, is contained)
+        if (!this.condition.value || typeof this.condition.value === 'string') {
+            this.condition.value = { molecule: (_a = this.condition.value) !== null && _a !== void 0 ? _a : '', threshold: 0.7 };
+        }
+        const moleculeInput = ui.input.molecule('', {
+            onValueChanged: () => {
+                this.condition.value.molecule = moleculeInput.value;
+                this.onChanged.next(this.condition);
+            }
+        });
+        const tresholdInput = ui.input.float('', {
+            value: this.condition.value.threshold,
+            min: 0,
+            max: 1,
+            step: 0.01
+        });
+        DG.debounce(tresholdInput.onChanged, 300).subscribe(() => {
+            this.condition.value.threshold = tresholdInput.value;
+            this.onChanged.next(this.condition);
+        });
+        this.root.append(ui.divV([moleculeInput.root, tresholdInput.root]));
+        this.root.style.paddingTop = '15px';
+    }
+}
+export class MultiValueConditionEditorString extends BaseConditionEditor {
+    initializeEditor(prop) {
+        if (!Array.isArray(this.condition.value)) {
+            this.condition.value = [];
+        }
+        const input = ui.input.list('', {
+            nullable: false,
+            value: this.condition.value,
+            onValueChanged: () => {
+                this.condition.value = input.value;
+                this.onChanged.next(this.condition);
+            }
+        });
+        this.root.append(input.root);
+    }
+}
+export class MultiValueConditionEditorInt extends BaseConditionEditor {
+    initializeEditor(prop) {
+        if (!Array.isArray(this.condition.value)) {
+            this.condition.value = [];
+        }
+        const input = ui.input.list('', {
+            nullable: false,
+            value: this.condition.value,
+            onValueChanged: () => {
+                this.condition.value = input.value.map((it) => parseInt(it));
+                this.onChanged.next(this.condition);
+            }
+        });
+        this.root.append(input.root);
+    }
+}
+export class MultiValueConditionEditorFloat extends BaseConditionEditor {
+    initializeEditor(prop) {
+        if (!Array.isArray(this.condition.value)) {
+            this.condition.value = [];
+        }
+        const input = ui.input.list('', {
+            nullable: false,
+            value: this.condition.value,
+            onValueChanged: () => {
+                this.condition.value = input.value.map((it) => parseFloat(it));
+                this.onChanged.next(this.condition);
+            }
+        });
+        this.root.append(input.root);
+    }
+}
+// Registry for both operators and editors
+export class ConditionRegistry {
+    constructor() {
+        this.typeOperators = new Map();
+        this.semTypeOperators = new Map();
+        this.editorRegistry = new Map();
+        this.initializeDefaultOperators();
+        this.initializeDefaultEditors();
+    }
+    static getInstance() {
+        if (!ConditionRegistry.instance) {
+            ConditionRegistry.instance = new ConditionRegistry();
+        }
+        return ConditionRegistry.instance;
+    }
+    initializeDefaultOperators() {
+        // Type operators
+        this.registerTypeOperators(DG.TYPE.BOOL, [Operators.EQ]);
+        this.registerTypeOperators(DG.TYPE.STRING, [Operators.STARTS_WITH, Operators.CONTAINS, Operators.EQ, Operators.NOT_EQ, Operators.IN]);
+        this.registerTypeOperators(DG.TYPE.INT, [Operators.GT, Operators.LT, Operators.GTE, Operators.LTE, Operators.EQ,
+            Operators.NOT_EQ, Operators.BETWEEN, Operators.IN]);
+        this.registerTypeOperators(DG.TYPE.FLOAT, [Operators.GT, Operators.LT, Operators.GTE, Operators.LTE, Operators.EQ,
+            Operators.NOT_EQ, Operators.BETWEEN, Operators.IN]);
+        this.registerTypeOperators(DG.TYPE.DATE_TIME, [Operators.BEFORE, Operators.AFTER, Operators.BETWEEN]);
+        // SemType operators (take precedence over type operators)
+        this.registerSemTypeOperators(DG.SEMTYPE.MOLECULE, [Operators.CONTAINS, Operators.IS_CONTAINED, Operators.EQ, Operators.IS_SIMILAR]);
+    }
+    initializeDefaultEditors() {
+        // Register default editors by property type (with empty semType and operator)
+        this.registerEditor(DG.TYPE.STRING, '', '', BaseConditionEditor);
+        this.registerEditor(DG.TYPE.INT, '', '', BaseConditionEditor);
+        this.registerEditor(DG.TYPE.FLOAT, '', '', BaseConditionEditor);
+        this.registerEditor(DG.TYPE.DATE_TIME, '', '', BaseConditionEditor);
+        this.registerEditor(DG.TYPE.BOOL, '', '', BaseConditionEditor);
+        // Register specialized editors for specific combinations
+        this.registerEditor(DG.TYPE.STRING, '', Operators.IN, MultiValueConditionEditorString);
+        this.registerEditor(DG.TYPE.INT, '', Operators.IN, MultiValueConditionEditorInt);
+        this.registerEditor(DG.TYPE.FLOAT, '', Operators.IN, MultiValueConditionEditorFloat);
+        this.registerEditor(DG.TYPE.DATE_TIME, '', Operators.BETWEEN, BetweenConditionEditor);
+        this.registerEditor(DG.TYPE.INT, '', Operators.BETWEEN, BetweenConditionEditor);
+        this.registerEditor(DG.TYPE.FLOAT, '', Operators.BETWEEN, BetweenConditionEditor);
+        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.CONTAINS, MoleculeConditionEditor);
+        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.IS_CONTAINED, MoleculeConditionEditor);
+        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.EQ, MoleculeConditionEditor);
+        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.IS_SIMILAR, MoleculeSimilarityConditionEditor);
+        this.registerEditor(DG.TYPE.BOOL, '', Operators.EQ, BooleanConditionEditor);
+    }
+    // Operator registration methods
+    registerTypeOperators(propertyType, operators) {
+        this.typeOperators.set(propertyType, operators);
+    }
+    registerSemTypeOperators(semType, operators) {
+        this.semTypeOperators.set(semType, operators);
+    }
+    // Get operators for a property
+    getOperatorsForProperty(property) {
+        // Check semType first, then fall back to type
+        const semTypeOps = this.semTypeOperators.get(property.semType);
+        if (semTypeOps)
+            return semTypeOps;
+        const typeOps = this.typeOperators.get(property.propertyType);
+        return typeOps || [];
+    }
+    // Check if operator is supported
+    isOperatorSupported(property, operator) {
+        const operators = this.getOperatorsForProperty(property);
+        return operators.includes(operator);
+    }
+    // Editor registration methods
+    registerEditor(propertyType, semType, operator, editorClass) {
+        const key = this.createEditorKey(propertyType, semType, operator);
+        this.editorRegistry.set(key, editorClass);
+    }
+    // Create editor for a property and operator
+    createEditor(property, operator, initialCondition) {
+        // Try to find a specialized editor first (propertyType + semType + operator)
+        const specializedKey = this.createEditorKey(property.propertyType, property.semType, operator);
+        let EditorClass = this.editorRegistry.get(specializedKey);
+        // If no specialized editor, try with empty semType (propertyType + operator)
+        if (!EditorClass) {
+            const typeOnlyKey = this.createEditorKey(property.propertyType, '', operator);
+            EditorClass = this.editorRegistry.get(typeOnlyKey);
+        }
+        // If still no specialized editor, use default editor for property type (propertyType only)
+        if (!EditorClass) {
+            const defaultKey = this.createEditorKey(property.propertyType, '', '');
+            EditorClass = this.editorRegistry.get(defaultKey);
+        }
+        // Fallback to base editor
+        if (!EditorClass) {
+            EditorClass = BaseConditionEditor;
+        }
+        return new EditorClass(property, operator, initialCondition);
+    }
+    // Get condition editor for a property and operator (with validation)
+    getConditionEditor(property, operator, condition) {
+        if (this.isOperatorSupported(property, operator)) {
+            return this.createEditor(property, operator, condition);
+        }
+        else {
+            throw Error(`Operator '${operator}' is not supported for property type '${property.propertyType}'`);
+        }
+    }
+    createEditorKey(propertyType, semType, operator) {
+        return `${propertyType}:${semType}:${operator}`;
+    }
+}
+export function saveHistory(key, value) {
+    var _a;
+    let collection = JSON.parse((_a = localStorage.getItem(key)) !== null && _a !== void 0 ? _a : '[]');
+    const newItem = { date: new Date(), value: value };
+    if (!collection.length)
+        localStorage.setItem(key, JSON.stringify([newItem]));
+    else {
+        collection = collection.filter((it) => it.value !== value);
+        localStorage.setItem(key, JSON.stringify([newItem, ...collection.slice(0, 9)]));
+    }
+}
+export function getHistory(key) {
+    var _a;
+    return JSON.parse((_a = localStorage.getItem(key)) !== null && _a !== void 0 ? _a : '[]');
+}
+export class QueryBuilder {
+    constructor(properties, initialCondition, layout = QueryBuilderLayout.Standard, _historyCacheKey = '') {
+        this.structureChanged = new Subject();
+        this.filterValueChanged = new Subject();
+        this.historyIcon = null;
+        this.properties = properties;
+        this.layout = layout;
+        this._historyCacheKey = _historyCacheKey;
+        if (initialCondition) {
+            this.condition = initialCondition;
+        }
+        else {
+            const defaultCondition = this.createDefaultSimpleCondition();
+            this.condition = {
+                logicalOperator: Operators.Logical.and,
+                conditions: [defaultCondition]
+            };
+        }
+        this.root = this.buildUI(this.condition, undefined, 0);
+        this.setupHistoryIcon();
+    }
+    set historyCache(key) {
+        this._historyCacheKey = key;
+        this.setupHistoryIcon(); // This will control visibility
+    }
+    saveConditionToHistory() {
+        if (this._historyCacheKey)
+            saveHistory(this._historyCacheKey, JSON.stringify(this.condition));
+    }
+    setupHistoryIcon() {
+        if (!this.historyIcon) {
+            this.historyIcon = ui.iconFA('history', () => {
+                this.showHistoryMenu();
+            }, 'Query History');
+            this.historyIcon.classList.add('query-builder-history-icon');
+        }
+        this.root.appendChild(this.historyIcon);
+        // Set data attribute for CSS to control visibility
+        if (this.root) {
+            this.root.setAttribute('data-history', this._historyCacheKey === '' ? 'false' : 'true');
+        }
+    }
+    showHistoryMenu() {
+        const items = getHistory(this._historyCacheKey);
+        const menu = DG.Menu.popup();
+        menu.items(items.map((it) => ui.tools.click(ui.divH([
+            ui.divText(it.date.toString(), { style: { color: '#7990A5' } }),
+            ui.divText(this.conditionToString(JSON.parse(it.value))),
+        ], { style: { gap: '5px' } }), () => { this.loadCondition(JSON.parse(it.value)); })), () => { });
+        menu.show();
+    }
+    loadCondition(condition) {
+        this.condition = JSON.parse(JSON.stringify(condition));
+        this.rebuildUI();
+        this.structureChanged.next(this.condition);
+    }
+    conditionToString(condition) {
+        if (!condition || !condition.conditions || condition.conditions.length === 0) {
+            return 'No conditions';
+        }
+        // If there's only one condition, don't wrap it in logical operator
+        if (condition.conditions.length === 1) {
+            return this.expressionToString(condition.conditions[0]);
+        }
+        // For multiple conditions, wrap them in logical operator
+        const logicalOp = condition.logicalOperator === Operators.Logical.and ? 'AND' : 'OR';
+        const conditionStrings = condition.conditions.map(cond => this.expressionToString(cond));
+        return `(${conditionStrings.join(` ${logicalOp} `)})`;
+    }
+    expressionToString(expression) {
+        if ('field' in expression) {
+            // This is a SimpleCondition
+            return this.simpleConditionToString(expression);
+        }
+        else {
+            // This is a ComplexCondition (recursive)
+            return this.conditionToString(expression);
+        }
+    }
+    simpleConditionToString(condition) {
+        const field = condition.field || 'Unknown field';
+        const operator = condition.operator || 'Unknown operator';
+        const value = condition.value !== undefined && condition.value !== null ?
+            (Array.isArray(condition.value) ? `[${condition.value.join(', ')}]` : String(condition.value)) :
+            'No value';
+        return `${field} ${operator} ${value}`;
+    }
+    createDefaultSimpleCondition() {
+        const firstProperty = this.properties[0];
+        if (firstProperty) {
+            const registry = ConditionRegistry.getInstance();
+            const operators = registry.getOperatorsForProperty(firstProperty);
+            const firstOperator = operators[0];
+            return {
+                field: firstProperty.name,
+                operator: firstOperator,
+                value: undefined
+            };
+        }
+        else
+            return {
+                field: '',
+                value: undefined,
+                operator: ''
+            };
+    }
+    rebuildUI() {
+        const newRoot = this.buildUI(this.condition, undefined, 0);
+        this.root.replaceWith(newRoot);
+        this.root = newRoot;
+        // Recreate history icon after rebuilding UI
+        this.setupHistoryIcon();
+    }
+    setLayout(layout) {
+        this.layout = layout;
+        if (layout === QueryBuilderLayout.Narrow)
+            this.root.classList.add('query-builder-narrow');
+        else
+            this.root.classList.remove('query-builder-narrow');
+        // Find all filter containers and apply/remove layout classes
+        const filterContainers = this.root.querySelectorAll('.query-builder-filter-inputs, .query-builder-filter-inputs-narrow');
+        filterContainers.forEach(container => {
+            if (layout === QueryBuilderLayout.Narrow) {
+                container.classList.remove('query-builder-filter-inputs');
+                container.classList.add('query-builder-filter-inputs-narrow');
+            }
+            else {
+                container.classList.remove('query-builder-filter-inputs-narrow');
+                container.classList.add('query-builder-filter-inputs');
+            }
+        });
+    }
+    getLayout() {
+        return this.layout;
+    }
+    buildUI(condition, parentCondition, nestingLevel = 0) {
+        var _a;
+        if (!condition) {
+            condition = {
+                logicalOperator: Operators.Logical.and,
+                conditions: []
+            };
+        }
+        const removeOrReplaceCondition = (condToRemove, condArray, replaceCond) => {
+            if (condArray) {
+                const condIdx = condArray.indexOf(condToRemove);
+                if (condIdx !== -1)
+                    replaceCond ? condArray[condIdx] = replaceCond : condArray.splice(condIdx, 1);
+            }
+            ;
+        };
+        const createPropertyFilterContainer = (cond, parentCondition) => {
+            var _a, _b;
+            const createFilter = () => {
+                ui.empty(operatorInputDiv);
+                const property = getPropByFriendlyName(fieldChoiceInput.value);
+                if (property) {
+                    const registry = ConditionRegistry.getInstance();
+                    const operators = registry.getOperatorsForProperty(property);
+                    if (!cond.operator || cond.operator === '') {
+                        cond.operator = operators[0];
+                        cond.value = undefined;
+                        this.filterValueChanged.next(cond);
+                    }
+                    const operatorsInput = ui.input.choice('', {
+                        value: cond.operator,
+                        items: operators,
+                        onValueChanged: () => {
+                            cond.operator = operatorsInput.value;
+                            this.rebuildUI();
+                            this.structureChanged.next(this.condition);
+                        },
+                        nullable: false
+                    });
+                    operatorInputDiv.append(operatorsInput.root);
+                    createEditor(property, cond.operator, cond);
+                }
+            };
+            const createEditor = (property, operator, condition) => {
+                ui.empty(criteriaDiv);
+                const registry = ConditionRegistry.getInstance();
+                const editor = registry.getConditionEditor(property, operator, condition);
+                editor.onChanged.subscribe(() => {
+                    this.filterValueChanged.next(editor.condition);
+                });
+                criteriaDiv.append(editor.root);
+            };
+            const getPropByName = (name) => {
+                const property = this.properties.find((prop) => prop.name === name);
+                return property;
+            };
+            const getPropByFriendlyName = (friendlyName) => {
+                let property = this.properties.find((prop) => prop.friendlyName === friendlyName);
+                if (!property)
+                    property = this.properties.find((prop) => prop.name === friendlyName);
+                return property;
+            };
+            const getFieldChoiceInputVal = (name) => {
+                var _a, _b;
+                const prop = getPropByName(name);
+                return (_b = (_a = prop === null || prop === void 0 ? void 0 : prop.friendlyName) !== null && _a !== void 0 ? _a : prop === null || prop === void 0 ? void 0 : prop.name) !== null && _b !== void 0 ? _b : '';
+            };
+            const getPropNameByChoiceInputVal = (friendlyName) => {
+                var _a;
+                const prop = getPropByFriendlyName(friendlyName);
+                return (_a = prop === null || prop === void 0 ? void 0 : prop.name) !== null && _a !== void 0 ? _a : '';
+            };
+            (_a = cond.field) !== null && _a !== void 0 ? _a : (cond.field = ((_b = this.properties[0]) === null || _b === void 0 ? void 0 : _b.name) || '');
+            const fieldChoiceInput = ui.input.choice('', {
+                items: this.properties.map((prop) => { var _a; return (_a = prop.friendlyName) !== null && _a !== void 0 ? _a : prop.name; }),
+                value: getFieldChoiceInputVal(cond.field),
+                nullable: false,
+                onValueChanged: () => {
+                    cond.field = getPropNameByChoiceInputVal(fieldChoiceInput.value);
+                    cond.value = undefined;
+                    cond.operator = '';
+                    createFilter();
+                    this.filterValueChanged.next(cond);
+                }
+            });
+            const deleteFieldIcon = ui.icons.delete(() => {
+                container.removeChild(filterContainer);
+                removeOrReplaceCondition(cond, parentCondition ? parentCondition.conditions : condition.conditions);
+                this.rebuildUI();
+                this.structureChanged.next(this.condition);
+            }, 'Remove current condition');
+            const addNestedConditionIcon = ui.icons.add(() => {
+                const parentCond = { logicalOperator: Operators.Logical.and, conditions: [cond] };
+                removeOrReplaceCondition(cond, parentCondition ? parentCondition.conditions : condition.conditions, parentCond);
+                this.rebuildUI();
+                this.structureChanged.next(this.condition);
+            }, 'Add nested condition');
+            const operatorInputDiv = ui.div('', 'query-builder-filter-operator');
+            const criteriaDiv = ui.div();
+            const filterContainer = ui.div([
+                ui.div([fieldChoiceInput.root], 'query-builder-filter-field'),
+                ui.div([operatorInputDiv], 'query-builder-filter-operator'),
+                ui.div([criteriaDiv], 'query-builder-filter-value'),
+                ui.div([deleteFieldIcon, addNestedConditionIcon], 'add-delete-icons')
+            ], this.layout === QueryBuilderLayout.Narrow ? 'query-builder-filter-inputs-narrow' : 'query-builder-filter-inputs');
+            container.appendChild(filterContainer);
+            createFilter();
+            this.filterValueChanged.next(cond);
+        };
+        // adding filter field
+        const addFieldIcon = ui.icons.add(() => {
+            var _a;
+            const conditionForFilter = this.createDefaultSimpleCondition();
+            (_a = condition.conditions) === null || _a === void 0 ? void 0 : _a.push(conditionForFilter);
+            condition.conditions.length < 2 ? container.classList.remove('property-query-builder-multipe-filelds') :
+                container.classList.add('property-query-builder-multipe-filelds');
+            this.rebuildUI();
+            this.structureChanged.next(this.condition);
+        }, 'Add field to the condition');
+        // AND/OR operators handling
+        (_a = condition.logicalOperator) !== null && _a !== void 0 ? _a : (condition.logicalOperator = Operators.Logical.and);
+        const logicalOperatorChoice = ui.input.choice('', {
+            value: condition.logicalOperator === Operators.Logical.and ? 'all' : 'any',
+            items: ['all', 'any'],
+            nullable: false,
+            onValueChanged: () => {
+                condition.logicalOperator = logicalOperatorChoice.value === 'all' ? Operators.Logical.and : Operators.Logical.or;
+                this.rebuildUI();
+                this.structureChanged.next(this.condition);
+            }
+        });
+        const logicalOperatorDiv = ui.divH([ui.divText('Match'), logicalOperatorChoice.root], 'query-builder-match-div');
+        const addDeleteIconsDiv = ui.divH([addFieldIcon], 'nested-add-delete-icons');
+        const iconsDiv = ui.divH([logicalOperatorDiv, addDeleteIconsDiv], 'query-builder-nested-condition-operators');
+        const container = ui.divV([iconsDiv], 'query-builder-search-query-operator');
+        if (nestingLevel > 0) {
+            container.setAttribute('data-nesting-level', nestingLevel.toString());
+            const color = this.generateNestingColor(nestingLevel);
+            container.style.setProperty('--nesting-color', color);
+        }
+        //delete icon for nested conditions to remove the whole nested condition at once
+        if (parentCondition) {
+            const deleteCondition = ui.icons.delete(() => {
+                removeOrReplaceCondition(condition, parentCondition.conditions);
+                this.rebuildUI();
+                this.structureChanged.next(this.condition);
+            });
+            addDeleteIconsDiv.append(deleteCondition);
+        }
+        for (const nestedCondition of condition.conditions) {
+            if ('field' in nestedCondition)
+                createPropertyFilterContainer(nestedCondition);
+            else {
+                const nestedContainer = this.buildUI(nestedCondition, condition, nestingLevel + 1);
+                container.append(nestedContainer);
+            }
+        }
+        condition.conditions.length < 2 ? container.classList.remove('property-query-builder-multipe-filelds') :
+            container.classList.add('property-query-builder-multipe-filelds');
+        return container;
+    }
+    generateNestingColor(level) {
+        const baseColor = { r: 187, g: 222, b: 251 };
+        const darkeningFactor = Math.min(0.1 + (level - 1) * 0.08, 0.9);
+        const r = Math.round(baseColor.r * (1 - darkeningFactor));
+        const g = Math.round(baseColor.g * (1 - darkeningFactor));
+        const b = Math.round(baseColor.b * (1 - darkeningFactor));
+        // Convert to hex
+        return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
+    }
+}
+function suggestionMenuKeyNavigation(inputContainer) {
+    inputContainer.addEventListener('keydown', (e) => {
+        var _a;
+        if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp' && e.key !== 'Enter')
+            return;
+        const currentlySelected = inputContainer.querySelector('.d4-menu-item-hover');
+        const allItems = Array.from((_a = inputContainer.querySelectorAll('.d4-menu-item')) !== null && _a !== void 0 ? _a : []);
+        if (!allItems || allItems.length === 0)
+            return;
+        allItems.sort((a, b) => a.offsetTop - b.offsetTop); // sort by vertical position
+        let currentIndex = currentlySelected ? allItems.indexOf(currentlySelected) : -1;
+        if (e.key === 'ArrowDown')
+            currentIndex = (currentIndex + 1) % allItems.length;
+        else if (e.key === 'ArrowUp')
+            currentIndex = (currentIndex - 1 + allItems.length) % allItems.length;
+        else if (e.key === 'Enter' && currentlySelected) {
+            currentlySelected.click();
+            e.preventDefault();
+            return;
+        }
+        currentlySelected === null || currentlySelected === void 0 ? void 0 : currentlySelected.classList.remove('d4-menu-item-hover');
+        allItems[currentIndex].classList.add('d4-menu-item-hover');
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-builder.js","sourceRoot":"","sources":["query-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\nimport { Subject } from 'rxjs';\nimport '../../css/query-builder.css';\nimport dayjs from 'dayjs';\n\nexport const SUGGESTIONS_FUNCTION = 'suggestionsFunction';\n\nexport namespace Operators {\n    export const CONTAINS = 'contains';\n    export const IN = 'in';\n    export const STARTS_WITH = 'starts with';\n    export const ENDS_WITH = 'ends with';\n    export const GT = '>';\n    export const GTE = '>=';\n    export const LT = '<';\n    export const LTE = '<=';\n    export const EQ = '=';\n    export const NOT_EQ = '!=';\n    export const BEFORE = 'before';\n    export const AFTER = 'after';\n    export const ON = 'on';\n    export const BETWEEN = 'between';\n    export const IS_SIMILAR = 'is similar';\n    export const IS_CONTAINED = 'is contained';\n\n    export enum Logical {\n        and = 'and',\n        or = 'or',\n    }\n}\n\nexport enum QueryBuilderLayout {\n    Standard = 'standard',\n    Narrow = 'narrow'\n}\n\nexport interface SimpleCondition<T = any> {\n    field: string;\n    operator: string;\n    value: T;\n}\n\nexport interface ComplexCondition {\n    logicalOperator: Operators.Logical;\n    conditions: Expression[];\n}\n\nexport type Expression<T = any> = SimpleCondition<T> | ComplexCondition;\n\n\nexport class BaseConditionEditor<T = any> {\n    root: HTMLDivElement = ui.div();\n    condition: SimpleCondition<T>;\n    onChanged: Subject<SimpleCondition<T>> = new Subject<SimpleCondition<T>>();\n    showSuggestions = false;\n    suggestionsMenuClicked = false;\n\n    constructor(prop: DG.Property, operator: string, initialCondition?: SimpleCondition<T>) {\n        this.condition = initialCondition ?? {\n            field: prop.name,\n            operator: operator,\n            value: undefined as T\n        };\n        this.initializeEditor(prop);\n    }\n\n    protected initializeEditor(prop: DG.Property): void {\n        if (Array.isArray(this.condition.value))\n            this.condition.value = undefined as T;\n        const initVal = prop.type === DG.TYPE.DATE_TIME && typeof this.condition.value === 'string' ?\n            dayjs(this.condition.value as string) : this.condition.value;\n        const input = ui.input.forProperty(prop, undefined, {\n            value: initVal,\n            nullable: false,\n            onValueChanged: () => {\n                this.condition.value = input.value as T;\n                this.onChanged.next(this.condition);\n                this.addSuggestions(prop, input);\n            }\n        });\n        input.addCaption('');\n        this.root.append(input.root);\n        this.initializeSuggestions(prop, input);\n    }\n\n    initializeSuggestions(prop: DG.Property, input: DG.InputBase) {\n        this.showSuggestions = prop.type === DG.TYPE.STRING && prop.options[SUGGESTIONS_FUNCTION];\n        if (this.showSuggestions) {\n           suggestionMenuKeyNavigation(this.root);\n        }\n    }\n\n    async addSuggestions(prop: DG.Property, input: DG.InputBase) {\n        if (this.showSuggestions && !this.suggestionsMenuClicked) {\n            if (input.value) {\n            const suggestions: Array<string> = await prop.options[SUGGESTIONS_FUNCTION](input.value);\n            if (suggestions.length === 1 && suggestions[0] === input.value)\n                return;\n            const suggestionsMenu = DG.Menu.popup();\n            suggestions.forEach((s) => {\n                suggestionsMenu!.item(s, () => {\n                    input.value = s;\n                    this.suggestionsMenuClicked = true;\n                });\n            });\n            suggestionsMenu.show({ element: input.root, y: input.root.offsetHeight });\n        }\n        }\n        this.suggestionsMenuClicked = false;\n    }\n}\n\nexport class BetweenConditionEditor extends BaseConditionEditor {\n    override initializeEditor(prop: DG.Property): void {\n        if (!this.condition.value || !Array.isArray(this.condition.value)) {\n            this.condition.value = [this.condition.value, undefined];\n            this.onChanged.next(this.condition);\n        }\n        const input1 = ui.input.forProperty(prop, this.condition.value[0], {\n            nullable: false,\n            onValueChanged: () => {\n                this.condition.value[0] = input1.value!;\n                this.onChanged.next(this.condition);\n            }\n        });\n        input1.addCaption('');\n        const input2 = ui.input.forProperty(prop, this.condition.value[1], {\n            value: this.condition.value[1],\n            onValueChanged: () => {\n                this.condition.value[1] = input2.value!;\n                this.onChanged.next(this.condition);\n            }\n        });\n        input2.addCaption('');\n        this.root.append(ui.divH([input1.root, input2.root], { style: { gap: '10px' } }));\n    }\n}\n\nexport class BooleanConditionEditor extends BaseConditionEditor {\n    override initializeEditor(prop: DG.Property): void {\n        if (!this.condition.value)\n            this.condition.value = true\n        const options = ['true', 'false'];\n        const input = ui.input.choice('', {\n            items: options,\n            nullable: false,\n            value: this.condition.value ? 'true' : 'false',\n            onValueChanged: () => {\n                this.condition.value = input.value === 'true';\n                this.onChanged.next(this.condition);\n            }\n        });\n        this.root.append(input.root);\n    }\n}\n\nexport class MoleculeConditionEditor extends BaseConditionEditor<string> {\n    override initializeEditor(prop: DG.Property): void {\n        //if we swith from similarity input to standard molecule input - need to modify value\n        if (this.condition.value && typeof this.condition.value !== 'string') {\n            if ('molecule' in this.condition.value)\n                 this.condition.value = (this.condition.value as MoleculeSimilarity).molecule;\n            else\n                this.condition.value = '';\n        }\n        const input = ui.input.molecule('', {\n            value: this.condition.value,\n            onValueChanged: () => {\n                this.condition.value = input.value;\n                this.onChanged.next(this.condition);\n            }\n        });\n        this.root.append(input.root);\n        //to adjust the filter width considering molecule input\n        this.root.style.paddingTop = '15px';\n        this.root.style.paddingBottom = '15px';\n    }\n}\n\nexport type MoleculeSimilarity = {\n    molecule: string,\n    threshold: number\n}\nexport class MoleculeSimilarityConditionEditor extends BaseConditionEditor<MoleculeSimilarity> {\n    override initializeEditor(prop: DG.Property): void {\n        //in case we switch from some other operator, where value is a string (contains, is contained)\n        if (!this.condition.value || typeof this.condition.value === 'string') {\n            this.condition.value = {molecule: this.condition.value ?? '', threshold: 0.7};\n        }\n        const moleculeInput = ui.input.molecule('', {\n            onValueChanged: () => {\n                this.condition.value.molecule = moleculeInput.value;\n                this.onChanged.next(this.condition);\n            }\n        });\n        const tresholdInput = ui.input.float('', {\n            value: this.condition.value.threshold,\n            min: 0,\n            max: 1,\n            step: 0.01\n        });\n        DG.debounce(tresholdInput.onChanged, 300).subscribe(() => {\n            this.condition.value.threshold = tresholdInput.value!;\n            this.onChanged.next(this.condition);\n        })\n        this.root.append(ui.divV([moleculeInput.root, tresholdInput.root]));\n        this.root.style.paddingTop = '15px';\n    }\n}\n\n\nexport class MultiValueConditionEditorString extends BaseConditionEditor<string[]> {\n    override initializeEditor(prop: DG.Property): void {\n        if (!Array.isArray(this.condition.value)) {\n            this.condition.value = [];\n        }\n        const input = ui.input.list('', {\n            nullable: false,\n            value: this.condition.value,\n            onValueChanged: () => {\n                this.condition.value = input.value!;\n                this.onChanged.next(this.condition);\n            }\n        });\n        this.root.append(input.root);\n    }\n}\n\nexport class MultiValueConditionEditorInt extends BaseConditionEditor<number[]> {\n    override initializeEditor(prop: DG.Property): void {\n        if (!Array.isArray(this.condition.value)) {\n            this.condition.value = [];\n        }\n        const input = ui.input.list('', {\n            nullable: false,\n            value: this.condition.value,\n            onValueChanged: () => {\n                this.condition.value = input.value!.map((it) => parseInt(it));\n                this.onChanged.next(this.condition);\n            }\n        });\n        this.root.append(input.root);\n    }\n}\n\nexport class MultiValueConditionEditorFloat extends BaseConditionEditor<number[]> {\n    override initializeEditor(prop: DG.Property): void {\n        if (!Array.isArray(this.condition.value)) {\n            this.condition.value = [];\n        }\n        const input = ui.input.list('', {\n            nullable: false,\n            value: this.condition.value,\n            onValueChanged: () => {\n                this.condition.value = input.value!.map((it) => parseFloat(it));\n                this.onChanged.next(this.condition);\n            }\n        });\n        this.root.append(input.root);\n    }\n}\n\n// Registry for both operators and editors\nexport class ConditionRegistry {\n    private static instance: ConditionRegistry;\n    private typeOperators: Map<string, string[]> = new Map();\n    private semTypeOperators: Map<string, string[]> = new Map();\n    private editorRegistry: Map<string, new (prop: DG.Property, operator: string, initialCondition?: any) => BaseConditionEditor> = new Map();\n\n    private constructor() {\n        this.initializeDefaultOperators();\n        this.initializeDefaultEditors();\n    }\n\n    static getInstance(): ConditionRegistry {\n        if (!ConditionRegistry.instance) {\n            ConditionRegistry.instance = new ConditionRegistry();\n        }\n        return ConditionRegistry.instance;\n    }\n\n    private initializeDefaultOperators(): void {\n        // Type operators\n        this.registerTypeOperators(DG.TYPE.BOOL, [Operators.EQ]);\n        this.registerTypeOperators(DG.TYPE.STRING, [Operators.STARTS_WITH, Operators.CONTAINS, Operators.EQ, Operators.NOT_EQ, Operators.IN]);\n        this.registerTypeOperators(DG.TYPE.INT, [Operators.GT, Operators.LT, Operators.GTE, Operators.LTE, Operators.EQ,\n            Operators.NOT_EQ, Operators.BETWEEN, Operators.IN]);\n        this.registerTypeOperators(DG.TYPE.FLOAT, [Operators.GT, Operators.LT, Operators.GTE, Operators.LTE, Operators.EQ,\n            Operators.NOT_EQ, Operators.BETWEEN, Operators.IN]);\n        this.registerTypeOperators(DG.TYPE.DATE_TIME, [Operators.BEFORE, Operators.AFTER, Operators.BETWEEN]);\n\n        // SemType operators (take precedence over type operators)\n        this.registerSemTypeOperators(DG.SEMTYPE.MOLECULE, [Operators.CONTAINS, Operators.IS_CONTAINED, Operators.EQ, Operators.IS_SIMILAR]);\n    }\n\n    private initializeDefaultEditors(): void {\n        // Register default editors by property type (with empty semType and operator)\n        this.registerEditor(DG.TYPE.STRING, '', '', BaseConditionEditor);\n        this.registerEditor(DG.TYPE.INT, '', '', BaseConditionEditor);\n        this.registerEditor(DG.TYPE.FLOAT, '', '', BaseConditionEditor);\n        this.registerEditor(DG.TYPE.DATE_TIME, '', '', BaseConditionEditor);\n        this.registerEditor(DG.TYPE.BOOL, '', '', BaseConditionEditor);\n\n        // Register specialized editors for specific combinations\n        this.registerEditor(DG.TYPE.STRING, '', Operators.IN, MultiValueConditionEditorString);\n        this.registerEditor(DG.TYPE.INT, '', Operators.IN, MultiValueConditionEditorInt);\n        this.registerEditor(DG.TYPE.FLOAT, '', Operators.IN, MultiValueConditionEditorFloat);\n        this.registerEditor(DG.TYPE.DATE_TIME, '', Operators.BETWEEN, BetweenConditionEditor);\n        this.registerEditor(DG.TYPE.INT, '', Operators.BETWEEN, BetweenConditionEditor);\n        this.registerEditor(DG.TYPE.FLOAT, '', Operators.BETWEEN, BetweenConditionEditor);\n        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.CONTAINS, MoleculeConditionEditor);\n        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.IS_CONTAINED, MoleculeConditionEditor);\n        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.EQ, MoleculeConditionEditor);\n        this.registerEditor(DG.TYPE.STRING, DG.SEMTYPE.MOLECULE, Operators.IS_SIMILAR, MoleculeSimilarityConditionEditor);\n        this.registerEditor(DG.TYPE.BOOL, '', Operators.EQ, BooleanConditionEditor);\n    }\n\n    // Operator registration methods\n    registerTypeOperators(propertyType: string, operators: string[]): void {\n        this.typeOperators.set(propertyType, operators);\n    }\n\n    registerSemTypeOperators(semType: string, operators: string[]): void {\n        this.semTypeOperators.set(semType, operators);\n    }\n\n    // Get operators for a property\n    getOperatorsForProperty(property: DG.Property): string[] {\n        // Check semType first, then fall back to type\n        const semTypeOps = this.semTypeOperators.get(property.semType);\n        if (semTypeOps) return semTypeOps;\n\n        const typeOps = this.typeOperators.get(property.propertyType);\n        return typeOps || [];\n    }\n\n    // Check if operator is supported\n    isOperatorSupported(property: DG.Property, operator: string): boolean {\n        const operators = this.getOperatorsForProperty(property);\n        return operators.includes(operator);\n    }\n\n    // Editor registration methods\n    registerEditor<T>(\n        propertyType: string,\n        semType: string,\n        operator: string,\n        editorClass: new (prop: DG.Property, operator: string) => BaseConditionEditor<T>\n    ): void {\n        const key = this.createEditorKey(propertyType, semType, operator);\n        this.editorRegistry.set(key, editorClass);\n    }\n\n    // Create editor for a property and operator\n    createEditor<T>(property: DG.Property, operator: string, initialCondition?: SimpleCondition<T>): BaseConditionEditor<T> {\n        // Try to find a specialized editor first (propertyType + semType + operator)\n        const specializedKey = this.createEditorKey(property.propertyType, property.semType, operator);\n        let EditorClass = this.editorRegistry.get(specializedKey);\n\n        // If no specialized editor, try with empty semType (propertyType + operator)\n        if (!EditorClass) {\n            const typeOnlyKey = this.createEditorKey(property.propertyType, '', operator);\n            EditorClass = this.editorRegistry.get(typeOnlyKey);\n        }\n\n        // If still no specialized editor, use default editor for property type (propertyType only)\n        if (!EditorClass) {\n            const defaultKey = this.createEditorKey(property.propertyType, '', '');\n            EditorClass = this.editorRegistry.get(defaultKey);\n        }\n\n        // Fallback to base editor\n        if (!EditorClass) {\n            EditorClass = BaseConditionEditor;\n        }\n\n        return new EditorClass(property, operator, initialCondition);\n    }\n\n    // Get condition editor for a property and operator (with validation)\n    getConditionEditor<T = any>(property: DG.Property, operator: string, condition?: SimpleCondition<T>): BaseConditionEditor<T> {\n        if (this.isOperatorSupported(property, operator)) {\n            return this.createEditor(property, operator, condition);\n        } else {\n            throw Error(`Operator '${operator}' is not supported for property type '${property.propertyType}'`);\n        }\n    }\n\n    private createEditorKey(propertyType: string, semType: string, operator: string): string {\n        return `${propertyType}:${semType}:${operator}`;\n    }\n}\n\n\nexport type HistoryItem = {\n    date: DG.TYPE.DATE_TIME,\n    value: string,\n}\n\nexport function saveHistory(key: string, value: string) {\n    let collection: HistoryItem[] = JSON.parse(localStorage.getItem(key) ?? '[]');\n    const newItem = { date: new Date(), value: value };\n    if (!collection.length)\n        localStorage.setItem(key, JSON.stringify([newItem]));\n    else {\n        collection = collection.filter((it) => it.value !== value)\n        localStorage.setItem(key, JSON.stringify([newItem, ...collection.slice(0, 9)]));\n    }\n}\n\nexport function getHistory(key: string): HistoryItem[] {\n    return JSON.parse(localStorage.getItem(key) ?? '[]');\n}\n\nexport class QueryBuilder {\n    root: HTMLElement;\n    condition: ComplexCondition;\n    properties: DG.Property[];\n    structureChanged: Subject<ComplexCondition> = new Subject<ComplexCondition>();\n    filterValueChanged: Subject<SimpleCondition> = new Subject<SimpleCondition>();\n    layout: QueryBuilderLayout;\n    private _historyCacheKey: string;\n    private historyIcon: HTMLElement | null = null;\n\n    constructor(properties: DG.Property[], initialCondition?: ComplexCondition, layout: QueryBuilderLayout = QueryBuilderLayout.Standard,\n        _historyCacheKey: string = '') {\n        this.properties = properties;\n        this.layout = layout;\n        this._historyCacheKey = _historyCacheKey;\n        \n        if (initialCondition) {\n            this.condition = initialCondition;\n        } else {\n            const defaultCondition = this.createDefaultSimpleCondition();\n            this.condition = {\n                    logicalOperator: Operators.Logical.and,\n                    conditions: [defaultCondition]\n            };\n        }\n\n        this.root = this.buildUI(this.condition, undefined, 0);\n        this.setupHistoryIcon();\n    }\n\n    set historyCache(key: string) {\n        this._historyCacheKey = key;\n        this.setupHistoryIcon(); // This will control visibility\n    }\n\n    saveConditionToHistory(): void {\n        if (this._historyCacheKey)\n            saveHistory(this._historyCacheKey, JSON.stringify(this.condition));\n    }\n\n    private setupHistoryIcon(): void {\n        if (!this.historyIcon) {\n            this.historyIcon = ui.iconFA('history', () => {\n                this.showHistoryMenu();\n            }, 'Query History');\n\n            this.historyIcon.classList.add('query-builder-history-icon');\n        }\n\n        this.root.appendChild(this.historyIcon);\n        \n        // Set data attribute for CSS to control visibility\n        if (this.root) {\n            this.root.setAttribute('data-history', this._historyCacheKey  === '' ? 'false' : 'true');\n        }\n    }\n\n    private showHistoryMenu(): void {\n        const items: HistoryItem[] = getHistory(this._historyCacheKey);\n        const menu = DG.Menu.popup();\n        menu.items(items.map((it) => ui.tools.click(\n            ui.divH([\n                ui.divText(it.date.toString(), {style: {color: '#7990A5'}}),\n                ui.divText(this.conditionToString(JSON.parse(it.value) as ComplexCondition)),\n            ], {style: {gap: '5px'}}),\n        () => {this.loadCondition(JSON.parse(it.value))})), () => {});\n        menu.show();\n    }\n\n    private loadCondition(condition: ComplexCondition): void {\n        this.condition = JSON.parse(JSON.stringify(condition));\n        this.rebuildUI();\n        this.structureChanged.next(this.condition);\n    }\n\n    conditionToString(condition: ComplexCondition): string {\n        if (!condition || !condition.conditions || condition.conditions.length === 0) {\n            return 'No conditions';\n        }\n\n        // If there's only one condition, don't wrap it in logical operator\n        if (condition.conditions.length === 1) {\n            return this.expressionToString(condition.conditions[0]);\n        }\n\n        // For multiple conditions, wrap them in logical operator\n        const logicalOp = condition.logicalOperator === Operators.Logical.and ? 'AND' : 'OR';\n        const conditionStrings = condition.conditions.map(cond => this.expressionToString(cond));\n        \n        return `(${conditionStrings.join(` ${logicalOp} `)})`;\n    }\n\n    private expressionToString(expression: Expression): string {\n        if ('field' in expression) {\n            // This is a SimpleCondition\n            return this.simpleConditionToString(expression);\n        } else {\n            // This is a ComplexCondition (recursive)\n            return this.conditionToString(expression);\n        }\n    }\n\n    private simpleConditionToString(condition: SimpleCondition): string {\n        const field = condition.field || 'Unknown field';\n        const operator = condition.operator || 'Unknown operator';\n        const value = condition.value !== undefined && condition.value !== null ? \n            (Array.isArray(condition.value) ? `[${condition.value.join(', ')}]` : String(condition.value)) : \n            'No value';\n        \n        return `${field} ${operator} ${value}`;\n    }\n\n    createDefaultSimpleCondition(): SimpleCondition {\n        const firstProperty = this.properties[0];\n        if (firstProperty) {\n            const registry = ConditionRegistry.getInstance();\n            const operators = registry.getOperatorsForProperty(firstProperty);\n            const firstOperator = operators[0];\n\n            return {\n                field: firstProperty.name,\n                operator: firstOperator,\n                value: undefined\n            }\n        } else\n            return {\n                field: '',\n                value: undefined,\n                operator: ''\n            }\n    }\n\n    rebuildUI(): void {\n        const newRoot = this.buildUI(this.condition, undefined, 0);\n        this.root.replaceWith(newRoot);\n        this.root = newRoot;\n        \n        // Recreate history icon after rebuilding UI\n        this.setupHistoryIcon();\n    }\n\n    setLayout(layout: QueryBuilderLayout): void {\n        this.layout = layout;\n\n        if (layout === QueryBuilderLayout.Narrow)\n            this.root.classList.add('query-builder-narrow');\n        else\n            this.root.classList.remove('query-builder-narrow');\n        \n        // Find all filter containers and apply/remove layout classes\n        const filterContainers = this.root.querySelectorAll('.query-builder-filter-inputs, .query-builder-filter-inputs-narrow');\n        \n        filterContainers.forEach(container => {\n            if (layout === QueryBuilderLayout.Narrow) {\n                container.classList.remove('query-builder-filter-inputs');\n                container.classList.add('query-builder-filter-inputs-narrow');\n            } else {\n                container.classList.remove('query-builder-filter-inputs-narrow');\n                container.classList.add('query-builder-filter-inputs');\n            }\n        });\n    }\n\n    getLayout(): QueryBuilderLayout {\n        return this.layout;\n    }\n\n    buildUI(\n        condition: ComplexCondition,\n        parentCondition?: ComplexCondition,\n        nestingLevel: number = 0\n    ): HTMLElement {\n\n        if (!condition) {\n            condition = {\n                logicalOperator: Operators.Logical.and,\n                conditions: []\n            };\n        }\n\n        const removeOrReplaceCondition = (condToRemove: Expression, condArray?: Expression[], replaceCond?: ComplexCondition) => {\n            if (condArray) {\n                const condIdx = condArray.indexOf(condToRemove);\n                if (condIdx !== -1)\n                    replaceCond ? condArray[condIdx] = replaceCond : condArray.splice(condIdx, 1)\n            };\n        }\n\n        const createPropertyFilterContainer = (cond: SimpleCondition, parentCondition?: ComplexCondition) => {\n\n            const createFilter = () => {\n                ui.empty(operatorInputDiv);\n                const property = getPropByFriendlyName(fieldChoiceInput.value!);\n                if (property) {\n                    const registry = ConditionRegistry.getInstance();\n                    const operators = registry.getOperatorsForProperty(property);\n                    if (!cond.operator || cond.operator === '') {\n                        cond.operator = operators[0];\n                        cond.value = undefined;\n                        this.filterValueChanged.next(cond);\n                    }\n                    const operatorsInput = ui.input.choice('', {\n                        value: cond.operator,\n                        items: operators,\n                        onValueChanged: () => {\n                            cond.operator = operatorsInput.value!;\n                            this.rebuildUI();\n                            this.structureChanged.next(this.condition);\n                        },\n                        nullable: false\n                    });\n                    operatorInputDiv.append(operatorsInput.root);\n                    createEditor(property, cond.operator, cond);\n                }\n            }\n\n            const createEditor = (property: DG.Property, operator: string, condition: SimpleCondition) => {\n                ui.empty(criteriaDiv);\n                const registry = ConditionRegistry.getInstance();\n                const editor = registry.getConditionEditor(property, operator, condition);\n                editor.onChanged.subscribe(() => {\n                    this.filterValueChanged.next(editor.condition);\n                })\n                criteriaDiv.append(editor.root);\n            }\n\n                       const getPropByName = (name: string) => {\n                const property = this.properties.find((prop: DG.Property) => prop.name === name);\n                return property;\n            }\n\n            const getPropByFriendlyName = (friendlyName: string) => {\n                let property = this.properties.find((prop: DG.Property) => prop.friendlyName === friendlyName);\n                if (!property)\n                    property = this.properties.find((prop: DG.Property) => prop.name === friendlyName);\n                return property;\n            }\n\n            const getFieldChoiceInputVal = (name: string) => {\n                const prop = getPropByName(name);\n                return prop?.friendlyName ?? prop?.name ?? '';\n            }\n\n            const getPropNameByChoiceInputVal = (friendlyName: string) => {\n                const prop = getPropByFriendlyName(friendlyName);\n                return prop?.name ?? '';\n            }\n\n            cond.field ??= this.properties[0]?.name || '';\n\n            const fieldChoiceInput = ui.input.choice('', {\n                items: this.properties.map((prop: DG.Property) => prop.friendlyName ?? prop.name),\n                value: getFieldChoiceInputVal(cond.field),\n                nullable: false,\n                onValueChanged: () => {\n                    cond.field = getPropNameByChoiceInputVal(fieldChoiceInput.value!);\n                    cond.value = undefined;\n                    cond.operator = '';\n                    createFilter();\n                    this.filterValueChanged.next(cond);\n                }\n            });\n\n            const deleteFieldIcon = ui.icons.delete(() => {\n                container.removeChild(filterContainer);\n                removeOrReplaceCondition(cond, parentCondition ? parentCondition.conditions : condition.conditions);\n                this.rebuildUI();\n                this.structureChanged.next(this.condition);\n            }, 'Remove current condition');\n\n            const addNestedConditionIcon = ui.icons.add(() => {\n                const parentCond = { logicalOperator: Operators.Logical.and, conditions: [cond] };\n                removeOrReplaceCondition(cond, parentCondition ? parentCondition.conditions : condition.conditions, parentCond);\n                this.rebuildUI();\n                this.structureChanged.next(this.condition);\n\n            }, 'Add nested condition');\n\n            const operatorInputDiv = ui.div('', 'query-builder-filter-operator');\n            const criteriaDiv = ui.div();\n\n            const filterContainer = ui.div([\n                ui.div([fieldChoiceInput.root], 'query-builder-filter-field'),\n                ui.div([operatorInputDiv], 'query-builder-filter-operator'),\n                ui.div([criteriaDiv], 'query-builder-filter-value'),\n                ui.div([deleteFieldIcon, addNestedConditionIcon], 'add-delete-icons')\n            ], this.layout === QueryBuilderLayout.Narrow ? 'query-builder-filter-inputs-narrow' : 'query-builder-filter-inputs');\n            \n            container.appendChild(filterContainer);\n            createFilter();\n            this.filterValueChanged.next(cond);\n        }\n\n        // adding filter field\n        const addFieldIcon = ui.icons.add(() => {\n            const conditionForFilter: SimpleCondition = this.createDefaultSimpleCondition();\n            condition.conditions?.push(conditionForFilter);\n            condition.conditions.length < 2 ? container.classList.remove('property-query-builder-multipe-filelds') :\n                container.classList.add('property-query-builder-multipe-filelds');\n            this.rebuildUI();\n            this.structureChanged.next(this.condition);\n        }, 'Add field to the condition');\n\n        // AND/OR operators handling\n        condition.logicalOperator ??= Operators.Logical.and;\n\n        const logicalOperatorChoice = ui.input.choice('', {\n            value: condition.logicalOperator === Operators.Logical.and ? 'all' : 'any',\n            items: ['all', 'any'],\n            nullable: false,\n            onValueChanged: () => {\n                condition.logicalOperator = logicalOperatorChoice.value! === 'all' ? Operators.Logical.and : Operators.Logical.or;\n                this.rebuildUI();\n                this.structureChanged.next(this.condition);\n            }\n        })\n\n        const logicalOperatorDiv = ui.divH([ui.divText('Match'), logicalOperatorChoice.root], 'query-builder-match-div');\n\n        const addDeleteIconsDiv = ui.divH([addFieldIcon], 'nested-add-delete-icons');\n        const iconsDiv = ui.divH([logicalOperatorDiv, addDeleteIconsDiv], 'query-builder-nested-condition-operators');\n        const container = ui.divV([iconsDiv], 'query-builder-search-query-operator');\n\n\n        if (nestingLevel > 0) {\n            container.setAttribute('data-nesting-level', nestingLevel.toString());\n            const color = this.generateNestingColor(nestingLevel);\n            container.style.setProperty('--nesting-color', color);\n        }\n\n        //delete icon for nested conditions to remove the whole nested condition at once\n        if (parentCondition) {\n            const deleteCondition = ui.icons.delete(() => {\n                removeOrReplaceCondition(condition, parentCondition.conditions);\n                this.rebuildUI();\n                this.structureChanged.next(this.condition);\n            });\n            addDeleteIconsDiv.append(deleteCondition);\n        }\n\n        for (const nestedCondition of condition.conditions!) {\n            if ('field' in nestedCondition)\n                createPropertyFilterContainer(nestedCondition);\n            else {\n                const nestedContainer = this.buildUI(nestedCondition as ComplexCondition,\n                    condition, nestingLevel + 1);\n                container.append(nestedContainer);\n            }\n        }\n\n        condition.conditions.length < 2 ? container.classList.remove('property-query-builder-multipe-filelds') :\n            container.classList.add('property-query-builder-multipe-filelds');\n\n        return container;\n    }\n\n    generateNestingColor(level: number): string {\n        const baseColor = { r: 187, g: 222, b: 251 };\n\n        const darkeningFactor = Math.min(0.1 + (level - 1) * 0.08, 0.9);\n\n        const r = Math.round(baseColor.r * (1 - darkeningFactor));\n        const g = Math.round(baseColor.g * (1 - darkeningFactor));\n        const b = Math.round(baseColor.b * (1 - darkeningFactor));\n\n        // Convert to hex\n        return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;\n    }\n}\n\n\nfunction suggestionMenuKeyNavigation(inputContainer: HTMLElement) {\n  inputContainer.addEventListener('keydown', (e) => {\n    if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp' && e.key !== 'Enter')\n      return;\n    const currentlySelected: HTMLElement | null = inputContainer.querySelector('.d4-menu-item-hover');\n    const allItems: HTMLElement[] = Array.from(inputContainer.querySelectorAll('.d4-menu-item') ?? []);\n    if (!allItems || allItems.length === 0)\n      return;\n    allItems.sort((a, b) => a.offsetTop - b.offsetTop); // sort by vertical position\n\n    let currentIndex = currentlySelected ? allItems.indexOf(currentlySelected) : -1;\n    if (e.key === 'ArrowDown')\n      currentIndex = (currentIndex + 1) % allItems.length;\n    else if (e.key === 'ArrowUp')\n      currentIndex = (currentIndex - 1 + allItems.length) % allItems.length;\n    else if (e.key === 'Enter' && currentlySelected) {\n      currentlySelected.click();\n      e.preventDefault();\n      return;\n    }\n    currentlySelected?.classList.remove('d4-menu-item-hover');\n    allItems[currentIndex].classList.add('d4-menu-item-hover');\n  });\n}\n\n"]}