@globisnv/cypress-core 0.0.2 → 0.0.4

package/dist/commands/GLO_commands.js

@@ -0,0 +1,2319 @@
+import { bottom, buttonSearch, check, contains, cypressWebsocketLoader, defaultTimeout, enabled, equal, greaterEqual, gridDropDown, gridInput, gridInputWithoutEnter, gridSelect, hideInCommandLog, input, isInvalid, noEqualBool, noSkipCheck, notEqual, parseLocalizedNumber, row, select, skipCheck, span, top, unCheck } from '../tsHelper.js';
+import { attachWebSocketSpy } from '../websocketDetector.js';
+//! File-specific helpers
+const monthNames = ['januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december'];
+const monthMap = new Map(monthNames.map((month, index) => [month, index + 1]));
+const monthNamesEN = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+monthNamesEN.forEach((month, index) => {
+    monthMap.set(month, index + 1);
+});
+const globisUrlTypes = ['globtake', 'globis_external_portal'];
+const viewModeButtons = ['btnList', 'btnDetail'];
+const extractSelectorParts = (selector) => {
+    const last = selector[selector.length - 1];
+    if (typeof last === 'number')
+        return { baseSelector: selector.slice(0, -1), index: last };
+    return { baseSelector: selector, index: 0 };
+};
+// When index refers to a grid row (element repeated per row), GLO_getElement handles row filtering via the full selector.
+// When index refers to a sub-input within a single element (e.g. a field with two inputs), the caller uses eq(index).
+// This helper distinguishes the two cases synchronously.
+const isGridRowSelector = (baseSelector, index) => {
+    if (index === 0)
+        return false;
+    const selectorStr = baseSelector.length === 2 ? `[data-cy$="${baseSelector[0]}.${baseSelector[1]}"]` : `[name="${baseSelector[0]}"]`;
+    const el = Cypress.$(`div[formslist]:not([hidden]) ${selectorStr}`)[0];
+    return !!el?.closest('[row-index]');
+};
+// Row queries must ignore grids that are not on screen, but neither obvious filter does that job.
+// Servoy marks the *containers* hidden - `div[formslist][hidden]` for background programs,
+// `[tabpane][hidden]` for closed tabs (see GLO_getElement) - so `[row-index]:not([hidden])` filters
+// nothing at all and matches rows of every grid in the DOM. `:visible` overshoots the other way:
+// AG Grid's ag-root and ag-viewport use `overflow: hidden`, so Cypress' out-of-bounds check reports
+// rendered-but-scrolled-past rows as hidden (measured: 14 of 21 rendered rows drop out of `:visible`
+// after scrolling a grid to the bottom). Filter on the container, which is what both were after.
+const isInOpenContainer = (_, el) => !el.closest('[hidden]');
+const pickByRowIndex = (chain, index, log = false) => {
+    if (log)
+        Cypress.log({ name: 'idx', message: String(index) });
+    return chain.filter((i, el) => {
+        const rowIndexEl = el.closest('[row-index]');
+        return rowIndexEl ? rowIndexEl.getAttribute('row-index') === String(index) : i === index;
+    });
+};
+Cypress.Commands.add('GLO_getElement', (selectorArg, options = {}) => {
+    const arr = selectorArg;
+    const hasIndex = typeof arr[arr.length - 1] === 'number';
+    const index = hasIndex ? arr[arr.length - 1] : undefined;
+    const strParts = (hasIndex ? arr.slice(0, -1) : arr);
+    const selector = strParts.length === 2 ? `[data-cy$="${strParts[0]}.${strParts[1]}"]` : `[name="${strParts[0]}"]`;
+    const safeCallerOpts = Object.fromEntries(Object.entries(options).filter(([, v]) => v !== undefined));
+    const getOpts = { timeout: defaultTimeout, log: true, ...safeCallerOpts };
+    const withinChain = cy.state('withinSubjectChain');
+    const withinSubject = withinChain ? cy.getSubjectFromChain(withinChain) : undefined;
+    if (!withinSubject) {
+        cy.wrap(null, { log: false, timeout: getOpts.timeout }).should(() => {
+            if (Cypress.$(`div[formslist]:not([hidden]) [tabpane][hidden] ${selector}`).length > 0) {
+                throw new Error(`GLO_getElement: element "${selector}" found in crumb but its tab is closed`);
+            }
+        });
+        const elementInCrumb = Cypress.$(`div[formslist] ${selector}`).length > 0;
+        if (elementInCrumb) {
+            const result = cy.get(`div[formslist]:not([hidden]) ${selector}`, getOpts);
+            return pickByRowIndex(result, index ?? 0, hasIndex);
+        }
+    }
+    const result = cy.get(selector, getOpts);
+    // Ponytail: sync DOM check — if element absent, skip filter so cy.get + should('not.exist') chain works
+    return hasIndex || Cypress.$(selector).length > 0 ? pickByRowIndex(result, index ?? 0, hasIndex) : result;
+});
+Cypress.Commands.add('GLO_getVisible', (elementName, timeOut = defaultTimeout) => {
+    return cy.get(elementName, { timeout: timeOut }).filter(':visible', { timeout: timeOut });
+});
+Cypress.Commands.add('GLO_checkUser', () => {
+    const username = String(Cypress.expose('username'));
+    if (/globisadmin/.exec(username.toLowerCase())) {
+        throw new Error('Deletion of created data not allowed when globisadmin. Please log in using cypress user to proceed testing.'); // Stop the test by throwing an error
+    }
+});
+Cypress.Commands.add('GLO_login', (company, urlType) => {
+    const loginType = String(Cypress.expose('loginType'));
+    if (!Cypress.expose('globisUrl')) {
+        throw new Error('No Globis URL defined as environment parameter!');
+    }
+    switch (loginType.toLocaleLowerCase()) {
+        case 'servoy':
+            cy.GLO_servoyLogin(company);
+            break;
+        case 'okta':
+            cy.GLO_oktaLogin(company, urlType);
+            break;
+        case 'default':
+            cy.GLO_defaultlogin(company, undefined, undefined, urlType);
+            break;
+        default:
+            throw new Error('Incorrect type for GLO_login. Available types: servoy, okta, default');
+    }
+});
+Cypress.Commands.add('GLO_defaultlogin', (company, usernameENV = 'username', passwordENV = 'password', urlType) => {
+    // Change the Url if necessary
+    let url = Cypress.expose('globisUrl');
+    if (urlType) {
+        const target = globisUrlTypes.includes(urlType) ? 'globis_online' : 'online';
+        url = url.replace(target, urlType);
+    }
+    if (cypressWebsocketLoader) {
+        cy.WS_visitWithSpy(url);
+    }
+    else {
+        cy.visit(url);
+    }
+    cy.GLO_checkLoadingIndicator();
+    urlType === 'globjob' ? fillInUserAndPasswordGlobjob(usernameENV) : fillInUserAndPasswordDefault(usernameENV, passwordENV);
+    if (company) {
+        cy.GLO_selectCompany(company);
+    }
+    cy.GLO_checkLoadingIndicator();
+    cy.get('body').then(($body) => {
+        if ($body.find('.svy-message-dialog .window-title').text() === 'Locked record') {
+            // biome-ignore plugin: wait for locked record dialog choice to register
+            cy.wait(15000);
+            cy.GLO_dialogChoice('!globis.label.yes!');
+        }
+    });
+    if (!urlType) {
+        cy.get('[data-cy="ng$main_form2.navbar_top"]', { timeout: 120000 }).should('exist');
+        cy.get('loading-indicator', { timeout: 1200000 }).should('not.exist');
+    }
+});
+const fillInUserAndPasswordDefault = (usernameENV, passwordENV) => {
+    cy.get('[data-cy="ng2$svy_nav_login.logoImage"]', { timeout: 120000 }).should('exist');
+    cy.GLO_checkLoadingIndicator(); // The logo might be visible but there can still be a loading indicator
+    cy.GLO_getElement(['ng2$svy_nav_login', 'txtUser'], { timeout: 30000 })
+        .find('input:visible', { timeout: 30000 })
+        .eq(0)
+        .clear()
+        .type(Cypress.expose(usernameENV));
+    cy.env([passwordENV]).then((envVars) => {
+        cy.GLO_getElement(['ng2$svy_nav_login', 'txtPass'])
+            .find('input')
+            .eq(0)
+            .clear()
+            .type(envVars[passwordENV], { log: false });
+    });
+    cy.get('[data-cy="ng2$svy_nav_login.btnLogin"]').click();
+    cy.GLO_checkLoadingIndicator();
+};
+const fillInUserAndPasswordGlobjob = (usernameENV) => {
+    cy.GLO_getElement(['mobile$svy_nav_login', 'txt_login'])
+        .find('input')
+        .eq(0)
+        .clear()
+        .type(Cypress.expose(usernameENV));
+    cy.get('[data-cy="mobile$svy_nav_login.btn_login"]').click();
+    cy.GLO_checkLoadingIndicator();
+};
+Cypress.Commands.add('GLO_defaultloginExtraUser', (usernameENV, passwordENV, company) => {
+    cy.GLO_getElement(['ng2$svy_nav_login', 'txtUser'], { timeout: 60000 }).should('exist');
+    fillInUserAndPasswordDefault(usernameENV, passwordENV);
+    if (company) {
+        cy.GLO_selectCompany(company);
+    }
+    cy.get('[data-cy="ng$main_form2.navbar_top"]', { timeout: 120000 }).should('exist');
+});
+const waitForWebSocketAfterOkta = () => {
+    cy.url({ timeout: 60000 }).should('not.include', new URL(Cypress.expose('oktaUrl')).hostname);
+    cy.window({ timeout: 60000 }).should((win) => {
+        const w = win;
+        if (!w.wsMessages)
+            attachWebSocketSpy(win);
+        assert.isTrue(w.wsMessages?.wsConnected === true);
+    });
+    cy.window().then((win) => {
+        cy.wrap(win.wsMessages).as('wsMessages');
+        cy.task('log', `WebSocket spy confirmed connected, ${win.wsMessages?.messages.length} messages captured so far`);
+    });
+};
+Cypress.Commands.add('GLO_oktaLogin', (company, urlType, skipvNavCheck) => {
+    // Change the Url if necessary
+    let url = Cypress.expose('globisUrl');
+    if (urlType) {
+        const target = globisUrlTypes.includes(urlType) ? 'globis_online' : 'online';
+        url = url.replace(target, urlType);
+    }
+    if (cypressWebsocketLoader) {
+        // Stateless Okta login redirects server side before any Servoy client boots, so there is
+        // no websocket to wait for on the first visit. Attach the spy to every document load and
+        // only assert the connection after the Okta round trip (see waitForWebSocketAfterOkta).
+        cy.on('window:before:load', (win) => {
+            attachWebSocketSpy(win);
+        });
+    }
+    cy.visit(url);
+    cy.task('log', 'Redirect to okta url');
+    cy.origin(Cypress.expose('oktaUrl'), () => {
+        cy.get('.o-form-input', { timeout: 60000 })
+            .find('[autocomplete="username"]')
+            .clear()
+            .type(Cypress.expose('username'));
+        cy.task('log', 'Filled in username');
+        cy.get('[type="submit"]').click();
+        cy.env(['password']).then(({ password }) => {
+            cy.get('.o-form-input')
+                .find('[type="password"]', { timeout: 20000 })
+                .type(password, { log: false });
+        });
+        cy.task('log', 'Filled in password');
+        cy.get('[type="submit"]').click();
+    });
+    if (company) {
+        cy.GLO_selectCompany(company);
+    }
+    if (cypressWebsocketLoader)
+        waitForWebSocketAfterOkta();
+    cy.task('log', 'Start navbar check');
+    if (!skipvNavCheck) {
+        const navbarSelectors = {
+            globtake: '[data-cy="gt$main.form_view_sidebar"]',
+            globis_external_portal: '[data-cy$="ep$main.sidemenu"]'
+        };
+        const selector = urlType ? navbarSelectors[urlType] : '[data-cy="ng$main_form2.navbar_top"]';
+        if (selector)
+            cy.get(selector, { timeout: 120000 }).should('exist');
+        cy.get('loading-indicator', { timeout: 1200000 }).should('not.exist');
+    }
+    else {
+        // This is in case the check is instable
+        // biome-ignore plugin: wait in case the check is instable
+        cy.wait(5000);
+        cy.GLO_checkLoadingIndicator();
+    }
+    cy.task('log', 'End navbar check');
+});
+Cypress.Commands.add('GLO_logout', () => {
+    cy.GLO_getElement(['ng$main_form2', 'navbar_top']).find('.lucide-LogOut').click();
+    cy.GLO_getVisible('.window-footer button.svy-btn-primary', 30000)
+        .contains(/^(Yes|Ja)$/)
+        .click();
+});
+Cypress.Commands.add('GLO_servoyLogin', (company) => {
+    if (cypressWebsocketLoader) {
+        cy.WS_visitWithSpy(Cypress.expose('globisUrl'));
+    }
+    else {
+        cy.visit(Cypress.expose('globisUrl'));
+    }
+    cy.GLO_checkLoadingIndicator();
+    cy.GLO_getElement(['ng2$svy_nav_login', 'txtUser'], { timeout: 30000 })
+        .find('input')
+        .eq(0)
+        .clear()
+        .type(Cypress.expose('username'));
+    cy.env(['password']).then(({ password }) => {
+        cy.GLO_getElement(['ng2$svy_nav_login', 'txtPass'])
+            .find('input')
+            .eq(0)
+            .clear()
+            .type(password, { log: false });
+    });
+    cy.GLO_addInput(['ng2$svy_nav_login', 'owner'], Cypress.expose('ownerName'));
+    cy.GLO_getElement(['ng2$svy_nav_login', 'btnLogin']).click();
+    cy.GLO_checkLoadingIndicator();
+    if (company) {
+        cy.GLO_selectCompany(company);
+    }
+    cy.get('[data-cy="ng$main_form2.navbar_top"]', { timeout: 120000 }).should('exist');
+});
+Cypress.Commands.add('GLO_clearData', (formulaName) => {
+    cy.GLO_searchHeader('Formulas', 'Formulas', 'Formulas');
+    cy.GLO_searchDataControl(formulaName);
+    cy.GLO_clickDatacontrolBrowserButton('btnEdit');
+    cy.GLO_clickButton(['ng$formula_dtl', 'btn_test_formula']);
+    cy.task('log', 'Delete records started');
+    cy.GLO_clickButton(['ng$test_formula_parameter', 'confirm']);
+    cy.GLO_clickDatacontrolBrowserButton('btnSave');
+    cy.GLO_closeDashboard();
+    cy.GLO_log('Delete records completed');
+});
+Cypress.Commands.add('GLO_clickButton', (selector, buttonType) => {
+    cy.GLO_getElement(selector)
+        .then(($element) => {
+        buttonType ? cy.wrap($element).find(`.${buttonType}`).click() : cy.wrap($element).click();
+    })
+        .then(() => {
+        cy.GLO_checkLoadingIndicator();
+    });
+});
+Cypress.Commands.add('GLO_clickButtonText', (textButton) => {
+    clickButtonTextHelper(textButton, '.dx-button-content');
+});
+export const clickButtonTextHelper = (textButton, buttonContainer) => {
+    cy.get(buttonContainer)
+        .contains(textButton)
+        .should('not.be.disabled')
+        .click()
+        .then(() => {
+        cy.GLO_checkLoadingIndicator();
+    });
+};
+Cypress.Commands.add('GLO_checkField', (selector, value, operator = equal, timeOut = 10000) => {
+    if (value === undefined)
+        return;
+    const { baseSelector, index } = extractSelectorParts(selector);
+    const inGrid = isGridRowSelector(baseSelector, index);
+    const effectiveSelector = inGrid ? selector : baseSelector;
+    const effectiveIndex = inGrid ? 0 : index;
+    function assertFieldVal($input) {
+        const normalizedValue = typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : value;
+        let inputVal;
+        if (typeof value === 'number') {
+            inputVal = $input.find('input[value]').length
+                ? Number($input.find('input[value]').eq(effectiveIndex).attr('value'))
+                : Number($input.find('.dx-texteditor-input').eq(effectiveIndex).val());
+        }
+        else {
+            // Trim spaces before and after the value, including html space ( ) and other unicode spaces
+            inputVal = String($input.find('.dx-texteditor-input').eq(effectiveIndex).val()).replace(/\s+/g, ' ').trim();
+        }
+        if (operator === equal) {
+            expect(inputVal).to.equal(normalizedValue);
+        }
+        else if (operator === notEqual) {
+            expect(inputVal).to.not.equal(normalizedValue);
+        }
+        else if (operator === contains) {
+            expect(inputVal).to.contain(normalizedValue);
+        }
+        else if (operator === greaterEqual && typeof normalizedValue === 'number' && typeof inputVal === 'number') {
+            expect(inputVal).to.be.gte(normalizedValue);
+        }
+        else {
+            throw new Error('Incorrect operator for GLO_checkField. Available operators: equal, notEqual, contains');
+        }
+    }
+    cy.GLO_getElement(effectiveSelector, { timeout: timeOut }).should(assertFieldVal);
+});
+Cypress.Commands.add('GLO_searchHeader', (solutionName, moduleName, programName) => {
+    cy.GLO_getElement(['ng$main_form2', 'navbar_top'], { timeout: 30000 }).find('.dx-texteditor-input').type(programName);
+    cy.GLO_getElement(['ng$main_form2', 'navbar_top'])
+        .find('.dx-texteditor-input')
+        .invoke('attr', 'aria-controls')
+        .then((dropDownId) => {
+        cy.contains(`#${dropDownId} .dx-scrollview-content .dx-item`, `${solutionName} - ${moduleName} - ${programName}`, { timeout: 30000 }).click();
+    });
+    cy.GLO_checkLoadingIndicator();
+    cy.GLO_log(` - Opened the following program: ${solutionName} - ${moduleName} - ${programName}`);
+});
+Cypress.Commands.add('GLO_searchDataControl', (elementName) => {
+    cy.GLO_getVisible('globiscomponents-data-control[name=datacontrol]')
+        .within(() => {
+        cy.get('.dx-texteditor-input').click();
+        cy.get('.dx-texteditor-input').type(`{selectall}{del}${elementName}{enter}`);
+    })
+        .then(() => {
+        cy.GLO_checkLoadingIndicator();
+    });
+});
+Cypress.Commands.add('GLO_checkLoadingIndicator', () => {
+    if (cypressWebsocketLoader) {
+        cy.WS_loadingCheck();
+    }
+    else {
+        // biome-ignore plugin: wait before checking loading indicator
+        cy.wait(1000);
+        cy.get('loading-indicator', { timeout: 1200000 }).should('not.exist');
+        cy.get('[data-cy="ng$main_form2.progress"] dx-progress-bar', { timeout: 1200000, log: false }).should('not.exist');
+    }
+});
+Cypress.Commands.add('GLO_clickDatacontrolBrowserButton', (buttonName, skipCheck = noSkipCheck) => {
+    const datacontrol = 'globiscomponents-data-control[name="datacontrol"]:visible';
+    const enabledButton = `${datacontrol} .item-container:has([disabled="false"]:has(#${buttonName}))`;
+    const clickAndCheck = () => {
+        cy.get(enabledButton, { timeout: 10000 }).click();
+        cy.GLO_checkLoadingIndicator();
+        // This is needed because loading indicator is unreliable
+        if (!skipCheck) {
+            switch (buttonName) {
+                case 'btnSave':
+                case 'btnCancel':
+                    cy.get('.navigation-item[selected="true"] span.fa-circle.pane-changed', { timeout: 30000 }).should('not.exist');
+                    break;
+                case 'btnAdd':
+                case 'btnEdit':
+                    cy.get('.navigation-item[selected="true"] span.fa-circle.pane-changed', { timeout: 30000 }).should('exist');
+                    break;
+            }
+        }
+    };
+    if (!viewModeButtons.includes(buttonName)) {
+        clickAndCheck();
+        return;
+    }
+    // btnList/btnDetail are disabled once their own view is active, and absent in programs without a list/detail toggle: in both cases there is nothing to click.
+    cy.get(datacontrol, { timeout: 10000 }).then(($datacontrol) => {
+        if (!$datacontrol.find(`.item-container [disabled="false"]:has(#${buttonName})`).length) {
+            cy.GLO_log(`${buttonName} is not available or its view is already active: click skipped`);
+            return;
+        }
+        clickAndCheck();
+    });
+});
+Cypress.Commands.add('GLO_clickDatacontrolViewerButton', (pageName, buttonName, skipCheck = noSkipCheck) => {
+    const IgnoredButtons = ['btnMenu', 'btnDelete', 'btnEdit', 'btnSave', 'btnPrint', 'btnClearAllFilters'];
+    // Scroll Into view can't because of same page is opend twice
+    cy.GLO_getElement([`ng$${pageName}_tab`, 'datacontrol_viewer'])
+        .within(() => {
+        cy.get(`#${buttonName}`).closest('.item-container').find('[disabled="false"]', { timeout: 10000 }).click();
+    })
+        .then(() => {
+        if (!IgnoredButtons.includes(buttonName) && !skipCheck)
+            cy.get(`div[formslist][hidden] [data-cy$="ng$${pageName}_tab.datacontrol_viewer"]`, { timeout: 60000 }).should('exist');
+        cy.GLO_checkLoadingIndicator();
+        if (buttonName === 'btnSave' && !skipCheck)
+            cy.GLO_getElement([`ng$${pageName}_tab`, 'datacontrol_viewer']).find('[title="Save record"][disabled="true"]', { timeout: 60000 });
+    });
+});
+Cypress.Commands.add('GLO_selectCompany', (companyName) => {
+    cy.GLO_addInput(['ng2$svy_nav_login', 'company'], companyName);
+    cy.get('[data-cy="ng2$svy_nav_login.btnLogin"]').click();
+});
+Cypress.Commands.add('GLO_checkbox', (selector, bool) => {
+    if (bool === undefined)
+        return;
+    checkBoxHelper(selector, bool, 'dx-check-box', '.dx-checkbox-icon');
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_switch', (selector, bool) => {
+    if (bool === undefined)
+        return;
+    checkBoxHelper(selector, bool, 'dx-switch', '.dx-switch-container');
+    cy.GLO_checkLoadingIndicator();
+});
+const checkBoxHelper = (selector, bool, dxElement, dxElementContainer) => {
+    // Retry mechanism in case the checkbox is 3-state version and doesn't switch to the desired state on first click.
+    const retries = 3;
+    const clickElement = (remaining = retries) => {
+        return cy
+            .GLO_getElement(selector)
+            .find(dxElement)
+            .filter(':visible')
+            .then(($element) => {
+            const currentState = $element[0].getAttribute('aria-checked');
+            if (currentState === String(bool))
+                return;
+            if (remaining <= 0)
+                throw new Error('Failed to set checkbox/switch to the desired state after multiple attempts.');
+            cy.GLO_getElement(selector)
+                .find(dxElement)
+                .find(dxElementContainer)
+                .filter(':visible')
+                .click()
+                .then(() => {
+                cy.GLO_checkLoadingIndicator();
+                clickElement(remaining - 1);
+            });
+        });
+    };
+    clickElement();
+};
+const GLO_inputValuelist = (selector, rawValue) => {
+    if (!rawValue)
+        return;
+    const selection = String(rawValue);
+    // Globis filters only the first part of a string — if '-' is present (compound valuelists) full-string filtering may fail.
+    const maxRetries = 3;
+    let attempts = 0;
+    let unsliced = false;
+    let filtered = false;
+    let dropdownValue = selection.includes('-') ? selection.split('-')[0].trim() : selection;
+    const { baseSelector: vlBaseSelector, index: vlIndex } = extractSelectorParts(selector);
+    const vlInGrid = isGridRowSelector(vlBaseSelector, vlIndex);
+    const vlEffectiveSelector = vlInGrid ? selector : vlBaseSelector;
+    const vlEffectiveIndex = vlInGrid ? 0 : vlIndex;
+    const getElement = () => cy.GLO_getElement(vlEffectiveSelector, { log: false });
+    // Helper uses cy.document() to escape any .within() scope
+    let dropDownId;
+    const getDropdown = (dropdownSelector = '', timeout) => {
+        return getElement()
+            .find('.dx-texteditor-input', { log: false })
+            .eq(vlEffectiveIndex)
+            .invoke({ log: false }, 'attr', 'aria-controls')
+            .then((newId) => {
+            if (newId)
+                dropDownId = newId;
+            const query = dropdownSelector ? `[id="${dropDownId}"] ${dropdownSelector}` : `[id="${dropDownId}"]`;
+            return cy
+                .document({ timeout: timeout ?? defaultTimeout, log: false })
+                .its('body', { log: false })
+                .find(query, { log: false });
+        });
+    };
+    cy.GLO_getElement(vlEffectiveSelector).find('.dx-texteditor-input:enabled', { log: false }).eq(vlEffectiveIndex).click();
+    getElement()
+        .find('.dx-texteditor-input:enabled', { log: false })
+        .eq(vlEffectiveIndex)
+        .should('have.attr', 'aria-controls')
+        .then((id) => {
+        dropDownId = id;
+        // Wait for dropdown to load its values.
+        getDropdown('.dx-scrollable-container')
+            .should('exist')
+            .then(($el) => {
+            if ($el[0].scrollHeight > $el[0].clientHeight) {
+                cy.wrap($el, { log: false }).invoke({ log: false }, 'scrollTop', 0);
+                cy.wrap($el, { log: false }).should(($e) => {
+                    expect($e[0].scrollTop).to.eq(0);
+                });
+            }
+        });
+        getDropdown(undefined, 30000).should(($el) => {
+            assert.exists($el[0]);
+            assert.notInclude($el[0].className, 'dx-empty-collection');
+            assert.isAbove($el
+                .find('.dx-item')
+                .toArray()
+                .filter((item) => (item.textContent || '').trim() !== '').length, 0);
+        });
+        getDropdown('.dx-scrollview-content .dx-item')
+            .should('exist')
+            .then(($list) => {
+            if (!clickExactMatch($list))
+                attemptDropdownSelect();
+        });
+        function attemptDropdownSelect() {
+            attempts++;
+            getDropdown('.dx-scrollview-content .dx-item').as('before', { type: 'static' });
+            cy.log(`Attempt __${attempts}__: Selecting dropdown value`);
+            getElement()
+                .find('.dx-texteditor-input:enabled', { log: false })
+                .eq(vlEffectiveIndex)
+                .then(($input) => {
+                if ($input.val() !== '') {
+                    cy.GLO_clearField(selector);
+                    if (filtered) {
+                        // After clearing a filtered dropdown we check dropdown correctly clears and updates. We then store this cleared version as new baseline 'before'
+                        cy.get('@before').then(($before) => {
+                            getDropdown('.dx-scrollview-content .dx-item', 30000)
+                                .should(($current) => {
+                                const initialTexts = [...$before].map((el) => el.innerText.trim());
+                                const currentTexts = [...$current].map((el) => el.innerText.trim());
+                                const hasChanged = !Cypress._.isEqual(currentTexts, initialTexts);
+                                // Also accept when the list is the same size or larger: branch-filtered valuelists
+                                // with few options won't change after clearing because the full list IS the filtered list.
+                                const listNotSmaller = currentTexts.length >= initialTexts.length;
+                                return expect(hasChanged || listNotSmaller, 'Dropdown updated after clear').to.be.true;
+                            })
+                                .then(() => {
+                                getDropdown('.dx-scrollview-content .dx-item').as('before', { type: 'static' });
+                            });
+                        });
+                    }
+                }
+                cy.wrap($input, { log: false }).type(dropdownValue);
+                filtered = true;
+            });
+            // Check if the value is correctly set
+            getElement()
+                .find('.dx-texteditor-input:enabled', { log: false })
+                .eq(vlEffectiveIndex)
+                .invoke({ log: false }, 'val')
+                .then((value) => {
+                if (value !== dropdownValue) {
+                    // Retry if the value is incorrect
+                    if (attempts < maxRetries) {
+                        filtered = false; // Wrong value check doesn't need to wait so we just retry before filtering even has to occur.
+                        cy.log(`Retrying... (attempt __${attempts}__)`);
+                        attemptDropdownSelect(); // Recursive call
+                    }
+                    else {
+                        throw new Error(`Failed to set dropdown value after ${maxRetries} attempts`);
+                    }
+                }
+                else {
+                    // Wait for dropdown to update after typing.
+                    cy.get('@before')
+                        .then(($before) => {
+                        getDropdown('.dx-scrollview-content .dx-item', 30000).should(($current) => {
+                            const initialTexts = [...$before].map((el) => el.innerText.trim());
+                            const currentTexts = [...$current].map((el) => el.innerText.trim());
+                            const hasChanged = !Cypress._.isEqual(currentTexts, initialTexts);
+                            const anyIncludes = currentTexts.every((text) => text.includes(dropdownValue));
+                            return expect(hasChanged || anyIncludes, `Dropdown updated or contains "${dropdownValue}" already`).to.be.true;
+                        });
+                    })
+                        .then(() => {
+                        getDropdown('.dx-scrollview-content .dx-item:visible', 15000).then(($list) => {
+                            // Try to click exact match; if that fails, re-run with full value instead of sliced value.
+                            if (!clickExactMatch($list) && !unsliced) {
+                                dropdownValue = selection;
+                                attempts = 0;
+                                unsliced = true;
+                                attemptDropdownSelect();
+                            }
+                        });
+                    });
+                }
+            });
+        }
+        const clickExactMatch = ($list) => {
+            const normalizeText = (el) => Cypress.$(el).text().replace(/\s+/g, ' ').trim();
+            const normalizedTarget = selection.replace(/\s+/g, ' ').trim();
+            const $filteredList = $list.filter((_, el) => normalizeText(el) !== '');
+            const exactMatch = $filteredList.filter((_, el) => normalizeText(el) === normalizedTarget);
+            if ($filteredList.length === 0) {
+                cy.log(`__No options available in dropdown to select "${selection}"__`);
+                throw new Error(`No options available in dropdown to select "${selection}"`);
+            }
+            // If _all_ values of the dropdown currently already contain targetText, we can assume to click the partial match since no further filtering will happen.
+            const allContain = $filteredList.length > 0 && $filteredList.toArray().every((el) => normalizeText(el).toLowerCase().includes(normalizedTarget.toLowerCase()));
+            const hasMatch = exactMatch.length > 0 || allContain;
+            if (hasMatch) {
+                const matchedText = exactMatch.length > 0 ? normalizeText(exactMatch[0]) : normalizeText($filteredList[0]);
+                cy.log(`__Clicking ${exactMatch.length > 0 ? 'exact' : 'partial'} match: "${matchedText}"__`);
+                // Using cy.wrap(match[0]) can give issue that element updated, so we need to 're-find' it
+                getDropdown('.dx-scrollview-content .dx-item')
+                    .filter((_, el) => (exactMatch.length > 0 ? normalizeText(el) === normalizedTarget : normalizeText(el).includes(normalizedTarget)))
+                    .first()
+                    .click({ log: false });
+                getDropdown('.dx-overlay-content.dx-popup-normal[role="dialog"]').should('not.exist'); // Ensure the dropdown is completely handled/closed after selection
+                getElement().then(($el) => {
+                    if (!$el.find('.dx-tagbox').length)
+                        cy.GLO_checkField(selector, selection, exactMatch.length === 0 ? contains : undefined);
+                });
+                return true;
+            }
+            else {
+                cy.log(`__No match found for "${selection}"__`);
+                return false;
+            }
+        };
+    });
+};
+Cypress.Commands.add('GLO_closeDashboard', () => {
+    cy.task('get', ['testFailed'], { log: false }).then(({ testFailed }) => {
+        if (testFailed)
+            return;
+        cy.get('.navigation-item-close', { timeout: 10000 }).click();
+        cy.GLO_getVisible('.svy-message-dialog', 30000).should('exist');
+        cy.get('.svy-message-dialog').should(($dialog) => {
+            expect($dialog.find('.window-title').text().trim()).to.match(/^(Confirm|Bevestigen)$/);
+            expect($dialog.find('.window-body').text().trim()).to.match(/^(Close all programs\?|Sluit alle programma's\?)$/);
+        });
+        cy.get('.svy-message-dialog')
+            .find('.svy-btn-primary')
+            .contains(/^(Yes|Ja)$/)
+            .should('exist')
+            .click();
+        cy.GLO_checkLoadingIndicator();
+    });
+});
+Cypress.Commands.add('GLO_selectTab', (selector, tabName, openOrClose) => {
+    cy.GLO_getElement(selector)
+        .contains('[tabcontainer] .tab', tabName)
+        .then(($tab) => {
+        const isOpenAttr = $tab[0].getAttribute('open'); // Attribute is a string 'true' or missing -> null
+        const isOpen = isOpenAttr === 'true'; // Convert to boolean
+        if (openOrClose !== isOpen) {
+            const action = openOrClose ? 'Opening' : 'Closing';
+            cy.log(`${action} tab ${tabName}`);
+            cy.wrap($tab).click();
+            cy.GLO_checkLoadingIndicator();
+        }
+        else {
+            cy.log(`Tab ${tabName} is already ${isOpen ? 'open' : 'closed'}.`);
+        }
+    });
+});
+Cypress.Commands.add('GLO_selectMenuButton', (buttonName, exactMatch = noEqualBool) => {
+    const searchParam = exactMatch ? new RegExp(`^\\s*${Cypress._.escapeRegExp(buttonName)}\\s*$`) : buttonName;
+    cy.GLO_clickDatacontrolBrowserButton('btnMenu');
+    cy.GLO_getVisible('.dx-submenu', 10000)
+        .contains(searchParam)
+        .click()
+        .then(() => {
+        cy.GLO_checkLoadingIndicator();
+    });
+    cy.GLO_log(` - Used workflow button '${buttonName}'`);
+});
+Cypress.Commands.add('GLO_selectMenuButtonControlView', (tabName, buttonName, exactMatch = noEqualBool) => {
+    const searchParam = exactMatch ? new RegExp(`^\\s*${Cypress._.escapeRegExp(buttonName)}\\s*$`) : buttonName;
+    cy.GLO_clickDatacontrolViewerButton(tabName, 'btnMenu');
+    cy.GLO_getVisible('.dx-submenu', 10000)
+        .contains(searchParam)
+        .click()
+        .then(() => {
+        cy.GLO_checkLoadingIndicator();
+    });
+    cy.GLO_log(` - Used workflow button '${buttonName}'`);
+});
+const navItem = (topBottom, programName, tabNumber, mode) => {
+    if (topBottom !== top && topBottom !== bottom)
+        throw new Error(`Incorrect type for GLO_${mode}Program. Available types: top, bottom`);
+    const location = topBottom === top ? 0 : 1;
+    const regex = new RegExp(`^${Cypress._.escapeRegExp(programName)}$`);
+    cy.get('drag-scroll')
+        .eq(location)
+        .within(() => {
+        const items = cy
+            .get('.navigation-item:not([hidden]) span:not([close-btn])')
+            .filter((_, el) => regex.test(el.textContent.trim()))
+            .parent();
+        const item = tabNumber !== undefined ? items.eq(tabNumber) : items.last();
+        if (mode === 'close')
+            item.find('[close-btn]').click();
+        else
+            item.find('span:not([close-btn])').first().click();
+    });
+    cy.GLO_checkLoadingIndicator();
+};
+Cypress.Commands.add('GLO_closeProgram', (topBottom, programName, tabNumber) => {
+    navItem(topBottom, programName, tabNumber, 'close');
+    cy.GLO_log(` - Closed program tab ${programName}`);
+});
+Cypress.Commands.add('GLO_dialogChoice', (confirmation) => {
+    // biome-ignore plugin: wait for dialog choice body to render
+    cy.wait(500);
+    cy.get('body').then(($body) => {
+        let CSSSearchStr;
+        if ($body.find('.svy-message-dialog').length > 0) {
+            CSSSearchStr = '.svy-message-dialog button';
+        }
+        else if ($body.find('.servoycore-dialog-body').length > 0) {
+            // Previous version
+            CSSSearchStr = '.servoycore-dialog-body button';
+        }
+        else if ($body.find('.svy-dialog.window').length > 0) {
+            // Another variant
+            CSSSearchStr = '.svy-dialog.window globiscomponents-button';
+        }
+        else {
+            cy.GLO_log('Popup not found, skipping dialog option');
+            return;
+        }
+        if ($body.find('.window-title.type-error').length > 0 && $body.find('.window-title.type-error').is(':visible')) {
+            cy.GLO_log('Error dialog, failing test. use GLO_dialogRequiredCheck.');
+            cy.wrap(null).should(() => {
+                throw new Error('Error dialog, failing test. use GLO_dialogRequiredCheck.');
+            });
+        }
+        let found = false;
+        cy.get(CSSSearchStr)
+            .each(($btn) => {
+            if ($btn.text().includes(confirmation) && !found) {
+                found = true; // Skip other buttons when button has been found
+                cy.wrap($btn)
+                    .contains(confirmation)
+                    .click()
+                    .then(() => {
+                    cy.GLO_checkLoadingIndicator();
+                });
+            }
+        })
+            .then(() => {
+            if (!found) {
+                cy.GLO_log('Popup button not found, skipping dialog option');
+            }
+        });
+    });
+});
+Cypress.Commands.add('GLO_addInputDialog', (text) => {
+    cy.get('.svy-message-dialog .window-body form', { timeout: 15000 }).then(($form) => {
+        const inputType = $form.children().first().prop('tagName').toLowerCase();
+        if (inputType === 'input') {
+            cy.wrap($form).find('input').clear().type(text);
+        }
+        else if (inputType === 'select') {
+            cy.wrap($form)
+                .find('select')
+                .select(text)
+                .should(($select) => {
+                expect(String($select.val()).trim()).to.eq(text);
+            });
+        }
+        else {
+            throw new Error('Unsupported input type');
+        }
+    });
+});
+const GLO_inputInput = (selector, value, options = {}) => {
+    const { selectAllDelete, ...typeOptions } = options;
+    const { baseSelector, index } = extractSelectorParts(selector);
+    const inGrid = isGridRowSelector(baseSelector, index);
+    cy.GLO_getElement(inGrid ? selector : baseSelector, { log: false, ...typeOptions }).then(($el) => {
+        const $target = $el.find('.dx-texteditor-input:not([disabled])').eq(inGrid ? 0 : index);
+        const isTextarea = $target.is('textarea');
+        if (selectAllDelete)
+            cy.wrap($target, { log: false }).clear();
+        else
+            cy.GLO_clearField(selector);
+        cy.wrap($target, { log: false }).type(value, typeOptions);
+        if (!isTextarea)
+            cy.wrap($target, { log: false }).type('{enter}');
+    });
+};
+const GLO_inputMonaco = (dataUri, value) => {
+    cy.window().then((win) => {
+        const monaco = win.monaco;
+        const model = monaco.editor.getModels().find((m) => m.uri.toString() === dataUri);
+        if (model)
+            model.setValue(value);
+        else
+            throw new Error(`No monaco model found for ${dataUri}`);
+    });
+};
+Cypress.Commands.add('GLO_addInput', (selector, value, options) => {
+    if (value === undefined)
+        return;
+    else if (typeof value === 'number')
+        value = String(value);
+    else if (typeof value === 'object')
+        value = JSON.stringify(value);
+    options = options || {};
+    const { selectAllDelete, ...getOptions } = options;
+    const { baseSelector, index } = extractSelectorParts(selector);
+    const inGrid = isGridRowSelector(baseSelector, index);
+    cy.GLO_getElement(inGrid ? selector : baseSelector, getOptions).then(($el) => {
+        const isDropdown = $el
+            .find('.dx-texteditor-input:not([disabled])')
+            .eq(inGrid ? 0 : index)
+            .closest('dx-select-box, dx-tag-box').length > 0;
+        if ($el.parent().is('globiscomponents-monacoeditor')) {
+            if (selectAllDelete)
+                throw new Error('Error: selectAllDelete option is not applicable for monaco inputs and will be ignored.');
+            cy.wrap($el, { timeout: 10000 })
+                .find('.monaco-editor', { timeout: 10000 })
+                .invoke({ timeout: 10000 }, 'attr', 'data-uri')
+                .should('exist')
+                .then((dataUri) => {
+                GLO_inputMonaco(String(dataUri), value);
+            });
+        }
+        else if (isDropdown) {
+            if (selectAllDelete)
+                throw new Error('Error: selectAllDelete option is not applicable for valuelist inputs and will be ignored.');
+            GLO_inputValuelist(selector, value);
+        }
+        else {
+            GLO_inputInput(selector, value, options);
+        }
+    });
+});
+Cypress.Commands.add('GLO_addDate', (type, selector, value) => {
+    if (!value)
+        return;
+    const dateParts = value.split('/');
+    switch (type) {
+        case input:
+            cy.GLO_addInput(selector, value);
+            break;
+        case select: // Select from popup
+            if (dateParts[0].length === 1)
+                dateParts[0] = `0${dateParts[0]}`;
+            cy.GLO_getElement(selector).find('.dx-dropdowneditor-icon').click();
+            // Select correct year
+            selectYear(Number(dateParts[2]));
+            // Select correct month
+            selectMonth(Number(dateParts[1]));
+            cy.GLO_getVisible('.dx-calendar-body')
+                .last()
+                .within(() => {
+                cy.get('tr:visible').find(`[data-value="${dateParts[2]}/${dateParts[1]}/${dateParts[0]}"]`).filter(':not(".dx-calendar-other-month")').click();
+            });
+            break;
+        default:
+            throw new Error('Incorrect type for GLO_addDate. Available types: input, inputName, select, selectName');
+    }
+});
+Cypress.Commands.add('GLO_uploadFile', (selector, relativePath) => {
+    cy.GLO_getElement(selector)
+        .find('input[type=file]')
+        .selectFile(relativePath, { force: true })
+        .then(() => {
+        cy.GLO_checkLoadingIndicator();
+    });
+});
+Cypress.Commands.add('GLO_uploadFileDialog', (relativePath) => {
+    cy.GLO_getVisible('div.svy-upload.active').find('input[type=file]').selectFile(relativePath, { force: true, action: 'drag-drop' });
+    cy.GLO_checkLoadingIndicator();
+    cy.GLO_getVisible('button.svy-upload-btn-upload').click();
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_filterGrid', (colId, selector, text, exactMatch = noEqualBool, filterType) => {
+    if (text === undefined)
+        return;
+    else if (typeof text === 'object')
+        text = JSON.stringify(text);
+    const textString = String(text);
+    const searchParam = exactMatch ? new RegExp(`^\\s*${Cypress._.escapeRegExp(textString)}\\s*$`) : textString;
+    cy.GLO_getElement(selector).within(() => {
+        cy.get(`.ag-header-cell[col-id="${colId}"]`).as('filterHeaderCell');
+        cy.get('@filterHeaderCell').find('input:not(:where([hidden] *))').filter(':enabled').clear().as('COM_filterGridInput');
+        if (text !== '')
+            cy.get('@COM_filterGridInput').type(textString);
+    });
+    cy.get('@COM_filterGridInput').then(($element) => {
+        if ($element[0].getAttribute('role') === 'combobox') {
+            cy.get('ngb-typeahead-window').find('button').contains(searchParam).click();
+        }
+        else {
+            cy.get('@COM_filterGridInput').type('{enter}');
+        }
+    });
+    if (filterType) {
+        cy.get('@filterHeaderCell').find('button').click();
+        cy.get('.ag-filter-menu .ag-filter-select .ag-picker-field-display').click();
+        // biome-ignore plugin: special dropdown for filter, doesn't work without small wait
+        cy.wait(250); // Special dropdown for filter, doesn't work without small wait..
+        cy.get('.ag-filter-menu .ag-picker-expanded')
+            .invoke('attr', 'aria-controls')
+            .then((dropDownId) => {
+            cy.get(`[id="${dropDownId}"]`)
+                .should('be.visible')
+                .within(() => {
+                cy.get('.ag-list-item').contains(filterType).should('be.visible').parent().click();
+            });
+        });
+        cy.GLO_checkAGLoader();
+        cy.get('.ag-filter-menu .ag-filter-select .ag-picker-field-display').should('contain.text', filterType);
+        cy.press(Cypress.Keyboard.Keys.ESC); // Close the filter menu
+    }
+    cy.GLO_checkLoadingIndicator();
+    cy.GLO_checkAGLoader();
+});
+Cypress.Commands.add('GLO_filterGridCustomView', (selector, headerName, text) => {
+    cy.GLO_getElement(selector).within(() => {
+        cy.contains('div.ag-header-cell', headerName)
+            .invoke('attr', 'aria-colindex')
+            .then((ariaColIndex) => {
+            cy.get('.ag-header-row-filter').find(`[aria-colindex="${ariaColIndex}"]`).find('input').filter(':enabled').clear().as('COM_filterGridInput');
+            if (text !== undefined && text !== '')
+                cy.get('.ag-header-row-filter').find(`[aria-colindex="${ariaColIndex}"]`).find('input').filter(':enabled').type(String(text));
+        });
+    });
+    cy.get('body').then(($body) => {
+        if ($body.find('ngb-typeahead-window').length > 0) {
+            cy.get('ngb-typeahead-window').find('button').contains(String(text)).click();
+        }
+    });
+    cy.GLO_checkAGLoader();
+});
+Cypress.Commands.add('GLO_switchCompany', (companyName) => {
+    cy.GLO_getElement(['ng$main_form2', 'navbar_top']).find('#userroles-dropdown').click();
+    cy.get('.dx-submenu').find(span).contains('Switch company').click();
+    cy.GLO_checkLoadingIndicator();
+    cy.get('.svy-dialog').find('.dx-dropdowneditor-icon').click();
+    cy.GLO_getVisible('.dx-scrollview-content').contains(companyName).click();
+    cy.GLO_clickButton(['ng$login_companies_dlg', 'btn_save']);
+});
+Cypress.Commands.add('GLO_getRole', (aliasName) => {
+    cy.GLO_getVisible('[userrole]').invoke('text').as(aliasName, { type: 'static' });
+});
+Cypress.Commands.add('GLO_checkValueGrid', (value, rowFilter, columnId, timeOut = 10000, interval, operator) => {
+    if (timeOut > 60000 && !interval)
+        interval = 10000;
+    validateGridValue(value, undefined, rowFilter, columnId, timeOut, interval, operator);
+});
+const selectYear = (targetYear) => {
+    cy.GLO_getVisible('.dx-calendar-navigator')
+        .last()
+        .find('span')
+        .invoke('text')
+        .then((currentDateJQuery) => {
+        const currentDate = currentDateJQuery;
+        const currentYear = Number(currentDate.split(' ')[1]);
+        if (currentYear < targetYear) {
+            cy.GLO_getVisible('i.dx-icon.dx-icon-chevronright').last().click();
+            // biome-ignore plugin: wait for year navigation click to register
+            cy.wait(500);
+            selectYear(targetYear);
+        }
+        else if (currentYear > targetYear) {
+            cy.GLO_getVisible('i.dx-icon.dx-icon-chevronleft').last().click();
+            // biome-ignore plugin: wait for year navigation click to register
+            cy.wait(500);
+            selectYear(targetYear);
+        }
+        // If Correct year do nothing
+    });
+};
+const selectMonth = (targetMonth) => {
+    cy.GLO_getVisible('.dx-calendar-navigator')
+        .last()
+        .find('span')
+        .invoke('text')
+        .then((currentDateJQuery) => {
+        const currentDate = currentDateJQuery;
+        const currentMonth = currentDate.split(' ')[0];
+        const currenMonthNumber = monthMap.get(currentMonth);
+        if (!currenMonthNumber)
+            throw new Error('Given month is invalid');
+        if (currenMonthNumber < targetMonth) {
+            cy.GLO_getVisible('i.dx-icon.dx-icon-chevronright').last().click();
+            // biome-ignore plugin: wait for month navigation click to register
+            cy.wait(500);
+            selectMonth(targetMonth);
+        }
+        else if (currenMonthNumber > targetMonth) {
+            cy.GLO_getVisible('i.dx-icon.dx-icon-chevronleft').last().click();
+            // biome-ignore plugin: wait for month navigation click to register
+            cy.wait(500);
+            selectMonth(targetMonth);
+        }
+        // If Correct month do nothing
+    });
+};
+Cypress.Commands.add('GLO_selectProgram', (topBottom, programName, tabnumber) => {
+    navItem(topBottom, programName, tabnumber, 'select');
+});
+Cypress.Commands.add('GLO_getRowInGrid', (rowFilter) => {
+    const rows = cy.get('.ag-center-cols-container [row-index]').filter(isInOpenContainer);
+    return typeof rowFilter === 'number' ? rows.eq(rowFilter) : rows.filter(`:contains("${rowFilter}")`).first();
+});
+Cypress.Commands.add('GLO_selectRowInGrid', (rowFilter) => {
+    let found = false;
+    if (typeof rowFilter === 'number') {
+        cy.get(`[row-id="root_${rowFilter}"]`).filter(isInOpenContainer).find('[data-ref="eInput"]').click();
+        return;
+    }
+    // Convert to array if it's a string
+    const filters = typeof rowFilter === 'string' ? [rowFilter] : rowFilter;
+    // Iterate through each row and check if it matches the filter
+    cy.get('[row-index]')
+        .filter(isInOpenContainer)
+        .each(($row) => {
+        const cellTexts = Array.from($row.find('.ag-cell-value')).map((el) => el.innerText.trim());
+        // Check to see if all requested values are present in any of the cells.
+        const matches = filters.every((filterValue) => cellTexts.some((val) => val.includes(filterValue)));
+        if (matches) {
+            found = true;
+            const rowId = $row.attr('row-id');
+            // No isInOpenContainer here: `.ag-root` is the grid of $row, which already passed that
+            // filter above, so everything inside shares its ancestors. The re-query is only needed
+            // because the checkbox lives in the pinned-left twin carrying the same row-id.
+            cy.wrap($row)
+                .closest('.ag-root')
+                .within(() => {
+                cy.get(`[row-id="${rowId}"]`).find('[data-ref="eInput"]').click();
+            });
+            return false; // Stop after the first match
+        }
+    })
+        .then(() => {
+        if (!found) {
+            throw new Error(`No row found matching all of the following values: ${filters.join(', ')}`);
+        }
+    });
+});
+Cypress.Commands.add('GLO_dblClickRowInGrid', (type, selector, value, columnId, skipCheck = noSkipCheck, equals = noEqualBool) => {
+    if (value === undefined)
+        return;
+    cy.GLO_getElement(selector)
+        .within(() => {
+        dblClickRowInGrid(type, value, columnId, equals);
+    })
+        .then(() => {
+        if (!skipCheck) {
+            cy.get('@COM_compId')
+                .then((compId) => {
+                cy.get(`[row-index][comp-id="${compId}"]`, { timeout: 300000 }).should('not.be.visible');
+            })
+                .then(() => {
+                cy.GLO_checkLoadingIndicator();
+            });
+        }
+        else {
+            cy.GLO_checkLoadingIndicator();
+        }
+    });
+});
+/**
+ *
+ * This a a helper function that will handle all action inside the within
+ * This is seperated because somtimes we don't need to be inside a within see popupwindow
+ */
+const dblClickRowInGrid = (type, value, columnId, equals) => {
+    const saveValues = ($div) => {
+        const rowIndex = $div.attr('row-index');
+        const compId = $div.attr('comp-id');
+        const selector = `[row-index="${rowIndex}"][comp-id="${compId}"]`;
+        cy.wrap(selector).as('COM_selectedRowSelector');
+        cy.wrap(compId).as('COM_compId');
+    };
+    const helper = (filterSelector) => {
+        if (columnId) {
+            cy.get('[row-index]')
+                .find(`[col-id="${columnId}"]`)
+                .filter(filterSelector, { timeout: 10000 })
+                .parentsUntil('.ag-center-cols-container')
+                .filter('[row-index]')
+                .first()
+                .then(saveValues);
+        }
+        else {
+            cy.get('[row-index]').filter(filterSelector, { timeout: 10000 }).first().then(saveValues);
+        }
+    };
+    cy.GLO_checkAGLoader();
+    switch (type) {
+        case row:
+            cy.GLO_getRowInGrid(Number(value)).then(saveValues);
+            break;
+        case span:
+            //* Equals(not working for Array)
+            if (equals) {
+                if (Array.isArray(value))
+                    throw new Error('Cannot use an array together with equals');
+                const regex = new RegExp(`^\\s*${String(value)}\\s*$`);
+                cy.get('[row-index]:visible')
+                    .find(columnId ? `[col-id="${columnId}"] ${span}` : span)
+                    .contains(regex, { timeout: 10000 })
+                    .parentsUntil('.ag-center-cols-container')
+                    .filter('[row-index]')
+                    .first()
+                    .then(saveValues);
+            }
+            else if (Array.isArray(value)) {
+                //* Array
+                if (columnId)
+                    throw new Error('Cannot use an array together with columnId');
+                const spansArray = String(value)
+                    .split(',')
+                    .map((span) => span.trim());
+                const filterSelector = spansArray.map((span) => `:contains("${span}")`).join('');
+                helper(filterSelector);
+            }
+            else {
+                //* One span
+                helper(`:contains("${value}")`);
+            }
+            break;
+        default:
+            throw new Error('Incorrect type for GLO_dblClickRowInGrid. Available types: row, span');
+    }
+    // The actual dblClick on the row
+    cy.get('@COM_selectedRowSelector').then((selector) => {
+        columnId ? cy.get(selector).find(`[col-id="${columnId}"]`).dblclick() : cy.get(selector).find('[aria-colindex]').eq(1).dblclick();
+    });
+};
+Cypress.Commands.add('GLO_clickRowInGrid', (value, columnId) => {
+    if (value === undefined)
+        throw new Error('Value missing for GLO_clickRowInGrid');
+    columnId ? cy.GLO_getRowInGrid(value).find(`[col-id="${columnId}"]`).click() : cy.GLO_getRowInGrid(value).children().first().click();
+    cy.GLO_checkLoadingIndicator();
+});
+// Shared popup-window search + grid selection logic used by GLO_popupWindow.
+// Assumes the search glass has already been clicked and the popup (`.window-body`) is open.
+const selectFromPopupWindow = (value, columnId, equals = noEqualBool) => {
+    const loadTimeout = 30000; // 30 seconds
+    // Helper consts to be able to check if grid has been updated with new data.
+    // Window-body is popup element
+    // Dynamically get the first columnId if there is no columnId given.
+    const loadingColumnId = () => columnId
+        ? cy.wrap(columnId)
+        : cy
+            .get('.window-body:visible .ag-center-cols-container [row-index="0"] [role="gridcell"]', { timeout: 30000 })
+            .filter((_, el) => Cypress.$(el).text().trim().length > 0)
+            .first()
+            .invoke('attr', 'col-id');
+    // So we dont have to repeat the whole command everywhere, just looks better in code below.
+    const searchData = () => loadingColumnId().then((colId) => cy.get(`.window-body [row-index] [col-id="${colId}"]`, { timeout: loadTimeout }).should(($els) => {
+        assert.equal($els.toArray().filter((item) => (item.textContent || '').trim() === '').length, 0, 'Grid cells should not have empty values');
+        assert.isTrue(Cypress.$('.ag-loading').length === 0 && Cypress.$('loading-indicator').length === 0, '(Grid) loadingindicator is not visible');
+    }));
+    // Actual function that checks if the grid has loaded and changed.
+    const assertGridLoadedAndChanged = (beforeSearch) => ($afterSearch) => {
+        const noLoadingIndicator = Cypress.$('loading-indicator').length === 0;
+        const noAGLoader = Cypress.$('.ag-loading').length === 0;
+        assert.isTrue(noAGLoader && noLoadingIndicator, '(Grid) loadingindicator is not visible');
+        const afterTexts = Array.from($afterSearch, (el) => el.textContent.trim());
+        const hasData = afterTexts.some((val) => !!val);
+        const newData = !Cypress._.isEqual(afterTexts, beforeSearch);
+        assert.isTrue(hasData && newData, 'Grid stabilized with new data');
+    };
+    // Get the state of the entries before searching. Save as an array of strings so its less heavy on the memory.
+    searchData()
+        .then(($els) => Array.from($els, (el) => el.textContent.trim()))
+        .as('beforeSearch');
+    cy.get('@beforeSearch').then((beforeSearch) => {
+        // If the value is already in the visible grid we can skip the whole search.
+        if (!beforeSearch.includes(String(value))) {
+            cy.GLO_getElement(['svy_nav_selection', 'search_criteria']).type(String(value));
+            cy.GLO_getElement(['svy_nav_selection', 'btn_search']).click();
+            searchData().should(assertGridLoadedAndChanged(beforeSearch));
+            if (columnId) {
+                cy.GLO_getVisible('[row-index]')
+                    .find(`[col-id="${columnId}"]`)
+                    .then(($list) => {
+                    // Only fill in columnId filter if there is no exact match in said column yet.
+                    const match = $list.filter((_, el) => new RegExp(`^\\s*${Cypress._.escapeRegExp(String(value))}\\s*$`).test(Cypress.$(el).text().trim()));
+                    if (match.length !== 1) {
+                        searchData()
+                            .then(($els) => Array.from($els, (el) => el.textContent.trim()))
+                            .as('beforeSearch');
+                        cy.GLO_getVisible('.window-body').within(() => {
+                            cy.GLO_getVisible(`.ag-header-cell[col-id="${columnId}"]`)
+                                .invoke('attr', 'aria-colindex')
+                                .then((ariaColIndex) => {
+                                cy.get('.ag-header-row-filter').find(`[aria-colindex="${ariaColIndex}"]`).find('input').filter(':enabled').clear().type(String(value));
+                            });
+                        });
+                        cy.get('body').then(($body) => {
+                            if ($body.find('ngb-typeahead-window').length > 0) {
+                                cy.get('ngb-typeahead-window').find('button').contains(String(value)).click();
+                            }
+                        });
+                        searchData().should(assertGridLoadedAndChanged(beforeSearch));
+                    }
+                    else {
+                        cy.log('No columnId filtering needed, skipping.');
+                    }
+                });
+            }
+            cy.GLO_getVisible('.window-body').within(() => {
+                dblClickRowInGrid(span, value, columnId, equals);
+            });
+        }
+        else {
+            cy.log('Value already exists in the grid, skipping search.');
+            cy.GLO_getVisible('.window-body').within(() => {
+                dblClickRowInGrid(span, value, columnId, equals);
+            });
+        }
+        cy.get('@COM_compId')
+            .then((compId) => {
+            cy.get(`[row-index][comp-id="${compId}"]`, { timeout: 10000 }).should('not.exist');
+        })
+            .then(() => {
+            cy.GLO_checkLoadingIndicator();
+        });
+    });
+};
+Cypress.Commands.add('GLO_popupWindow', (selector, value, columnId, equals = noEqualBool, useMagnifierFlag = buttonSearch) => {
+    if (!value)
+        return;
+    if (useMagnifierFlag) {
+        cy.GLO_clearField(selector);
+        cy.GLO_clickButton(selector, 'fa-search');
+    }
+    else {
+        // Clear the input itself rather than through GLO_clearField: on a selector field the
+        // clear icon can be pressed without the value going away, and the typed value then lands
+        // behind the old one.
+        cy.GLO_addInput(selector, value, { selectAllDelete: true });
+        cy.GLO_checkLoadingIndicator();
+    }
+    cy.get('body').then(($body) => {
+        if ($body.find('.window-body').filter(':visible').length > 0) {
+            selectFromPopupWindow(value, columnId, equals);
+        }
+        else {
+            cy.GLO_checkField(selector, value, equals ? contains : undefined);
+        }
+    });
+});
+Cypress.Commands.add('GLO_selectMenuButtonLeft', (buttonName) => {
+    cy.GLO_getElement(['ng$main_form2', 'navbar_left']).within(() => {
+        switch (buttonName) {
+            case 'home':
+                cy.get('[class="lucide lucide-house"]').click();
+                break;
+            case 'settings':
+                cy.get('[class="lucide lucide-settings"]').click();
+                break;
+            case 'help':
+                cy.get('[class="lucide lucide-circle-question-mark"]').click();
+                break;
+            case 'support':
+                cy.get('[class="lucide lucide-headphones"]').click();
+                break;
+            case 'excel':
+                cy.get('[class="lucide lucide-file-x"]').click();
+                break;
+            case 'info':
+                cy.get('[class="lucide lucide-info"]').click();
+                break;
+            case 'refresh':
+                cy.get('[class="lucide lucide-rotate-cw"]').click();
+                break;
+            case 'query':
+                cy.get('[class="lucide lucide-database"]').click();
+                break;
+            case 'clients':
+                cy.get('[class="lucide lucide-users"]').click();
+                break;
+            case 'users':
+                cy.get('[class="lucide lucide-user-cog"]').click();
+                break;
+            case 'theme':
+                cy.get('[class="lucide lucide-sun"]').click();
+                break;
+            default:
+                throw new Error('Incorrect type for GLO_selectMenuButtonLeft. Available types: home, settings, excel, info, refresh');
+        }
+    });
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_changeUser', (username) => {
+    cy.GLO_selectMenuButtonLeft('users');
+    cy.GLO_addInput(['ng$log_in_as_other_user_dlg', 'sec_user_id'], username);
+    cy.GLO_checkLoadingIndicator();
+    cy.GLO_clickButton(['ng$log_in_as_other_user_dlg', 'btn_ok']);
+    cy.get('body', { timeout: 30000 }).find('[data-cy$="ng$log_in_as_other_user_dlg.btn_ok"]', { timeout: 30000 }).should('not.exist');
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_selectCustomView', (customViewName, subMenuName) => {
+    cy.GLO_clickDatacontrolBrowserButton('btnCustomViews');
+    if (subMenuName) {
+        const menuPath = Array.isArray(customViewName) ? customViewName : [customViewName];
+        const hoverThroughLevels = (path, index) => {
+            if (index >= path.length) {
+                const subRegex = new RegExp(`^\\s*${Cypress._.escapeRegExp(subMenuName)}\\s*$`);
+                cy.get('.dx-menu-item-text', { timeout: 10000 })
+                    .contains(subRegex)
+                    .click()
+                    .then(() => {
+                    cy.GLO_checkLoadingIndicator();
+                });
+                return;
+            }
+            const levelRegex = new RegExp(`^\\s*${Cypress._.escapeRegExp(path[index])}\\s*$`);
+            cy.get('.dx-menu-item', { timeout: 10000 })
+                .contains('.dx-menu-item-text', levelRegex)
+                .closest('.dx-menu-item')
+                .trigger('mouseover')
+                .should('be.visible')
+                .then(() => {
+                hoverThroughLevels(path, index + 1);
+            });
+        };
+        hoverThroughLevels(menuPath, 0);
+    }
+    else {
+        const singleViewName = Array.isArray(customViewName) ? customViewName[0] : customViewName;
+        let searchPattern;
+        if (singleViewName.includes('Save grid state')) {
+            searchPattern = /^\s*Save grid state( as \.\.\.)?\s*$/;
+        }
+        else {
+            searchPattern = new RegExp(`^\\s*${Cypress._.escapeRegExp(singleViewName)}\\s*$`);
+        }
+        cy.get('.dx-menu-item-text', { timeout: 10000 })
+            .contains(searchPattern)
+            .click()
+            .then(() => {
+            cy.GLO_checkLoadingIndicator();
+        });
+    }
+});
+Cypress.Commands.add('GLO_dblClickLabel', (selector, labelValue) => {
+    cy.GLO_getElement(selector)
+        .contains(labelValue)
+        .dblclick()
+        .then(() => {
+        cy.GLO_checkLoadingIndicator();
+    });
+});
+Cypress.Commands.add('GLO_validateCheckbox', (selector, value) => {
+    if (value === undefined)
+        return;
+    cy.GLO_getElement(selector).find('dx-check-box').invoke('attr', 'aria-checked').should('eq', value);
+});
+/**
+ * Command to check the presence of the AG Grid loader and wait for it to disappear.
+ * It ensures that the AG Grid has finished loading.
+ */
+Cypress.Commands.add('GLO_checkAGLoader', () => {
+    // biome-ignore plugin: wait because AGLoader is not instant
+    cy.wait(1000); // Wait because AGLoader is not instant
+    cy.get('.ag-loading', { timeout: 600000 }).should('not.exist');
+});
+Cypress.Commands.add('GLO_log', (logValue) => {
+    cy.task('log', logValue);
+});
+Cypress.Commands.add('GLO_storeValue', (selector, asValue, log = hideInCommandLog) => {
+    cy.GLO_getElement(selector)
+        .find('.dx-texteditor-input')
+        .invoke('val')
+        .then((text) => {
+        cy.wrap(text).as(asValue);
+        if (log)
+            cy.GLO_log(`${asValue}: ${String(text)}`);
+    });
+});
+Cypress.Commands.add('GLO_storeValueGrid', (selector, rowFilter, columnId, asValue, log = hideInCommandLog) => {
+    if (typeof rowFilter === 'string') {
+        cy.GLO_getElement(selector).within(() => {
+            cy.GLO_getAllRowsInGrid()
+                .filter(`:contains("${rowFilter}")`)
+                .eq(0)
+                .find(`[col-id="${columnId}"]`)
+                .should('not.have.text', '')
+                .then((cell) => {
+                const text = cell.text().trim();
+                cy.wrap(text).as(asValue);
+                if (log)
+                    cy.GLO_log(`${asValue}: ${text}`);
+            });
+        });
+    }
+    else {
+        cy.GLO_getElement(selector).within(() => {
+            cy.GLO_getRowInGrid(rowFilter)
+                .find(`[col-id="${columnId}"]`)
+                .should('not.have.text', '')
+                .then((cell) => {
+                const text = cell.text().trim();
+                cy.wrap(text).as(asValue);
+                if (log)
+                    cy.GLO_log(`${asValue}: ${text}`);
+            });
+        });
+    }
+});
+Cypress.Commands.add('GLO_checkNumberOfRowsInGrid', (selector, numberToValidate, lengthCondition = 'have.length', timeOut) => {
+    const slowPollThreshold = 15000;
+    const pollInterval = 5000;
+    const HEADER_ROWS = 2;
+    const getAriaRowcount = ($grid) => parseInt($grid.find('[role="grid"]').attr('aria-rowcount') || '0', 10);
+    // Column header row + filter row, counted in the center viewport only (the pinned-left and
+    // pinned-right containers repeat those same header rows).
+    const headerRowCount = ($grid) => $grid.find('.ag-header-viewport .ag-header-row').length || HEADER_ROWS;
+    const isLazyLoaded = ($grid) => {
+        const ariaRowcount = getAriaRowcount($grid);
+        const renderedRows = $grid.find('.ag-center-cols-container [row-index]').length;
+        return renderedRows > 0 && (ariaRowcount === -1 || ariaRowcount > renderedRows + headerRowCount($grid));
+    };
+    // When a client-side column filter is active, the tab-/datacontrol-counter still shows the
+    // unfiltered foundset total, so we must count the rendered (filtered) rows instead.
+    const hasActiveColumnFilter = ($grid) => $grid.find('.ag-header-cell.ag-header-cell-filtered').length > 0 ||
+        $grid.find('.ag-header-cell input').filter((_, el) => el.value.trim() !== '').length > 0;
+    const getCountFromTabLabel = ($grid) => {
+        const $tabs = $grid.closest('[data-cy$=".tabs"]').addBack().filter('[data-cy$=".tabs"]').add($grid.parents().filter('[data-cy]').first().find('[data-cy$=".tabs"]'));
+        const text = $tabs.find('[open="true"] span').first().text();
+        const match = /\((\d+)\)/.exec(text);
+        if (!match)
+            return null;
+        return parseInt(match[1], 10);
+    };
+    const getCountFromDataControl = ($grid) => {
+        const text = $grid.closest('.formslist').find('#txtCount').text().trim();
+        const parts = text.split('/');
+        if (parts.length !== 2)
+            return null;
+        const total = parseInt(parts[1].trim(), 10);
+        return Number.isNaN(total) ? null : total;
+    };
+    // AG Grid publishes the displayed row total (header rows included, pinned "sum" rows
+    // excluded) in aria-rowcount, so a virtualised grid still reports rows the viewport never
+    // rendered. Verified on ng$consignment_dtl_general.grid: 25 goods -> aria-rowcount 27 with
+    // 2 header rows, while only 12 rows exist in the DOM.
+    const getCountFromAriaRowcount = ($grid) => {
+        const total = getAriaRowcount($grid) - headerRowCount($grid);
+        return total >= 0 ? total : null; // An aria-rowcount of -1 means the total is unknown (infinite row model)
+    };
+    // Form-level counters (#txtCount navigator, tab "(n)" label) only match a grid on list
+    // forms. On non-lst forms with multiple grids the navigator reads the form's own (often
+    // 0/0) foundset, so fall back to ag-grid's own row count there.
+    const formIsListForm = /lst$/i.test(selector[0]);
+    const getTotalCount = ($grid) => {
+        if (!isLazyLoaded($grid))
+            return null; // Everything is rendered: counting the DOM rows is exact
+        if (!formIsListForm)
+            return getCountFromAriaRowcount($grid);
+        if (hasActiveColumnFilter($grid))
+            return null;
+        return getCountFromTabLabel($grid) ?? getCountFromDataControl($grid) ?? getCountFromAriaRowcount($grid);
+    };
+    const toNumberAssertion = (condition) => {
+        const stripped = condition.replace('have.length', '').split('.').filter(Boolean).join('.').trim();
+        if (!stripped)
+            return 'equal';
+        return `be.${stripped}`;
+    };
+    const runChainAssertion = (subject) => {
+        const effectiveCondition = typeof subject === 'number' ? toNumberAssertion(lengthCondition) : lengthCondition;
+        const parts = effectiveCondition.split('.');
+        let assertion = expect(subject).to;
+        let context = assertion;
+        for (const part of parts) {
+            context = assertion;
+            if (!(part in assertion))
+                throw new Error(`Invalid Chai property: ${part} in chain "${effectiveCondition}"`);
+            assertion = assertion[part];
+        }
+        if (typeof assertion !== 'function')
+            throw new Error(`${effectiveCondition} did not resolve to a function`);
+        assertion.call(context, numberToValidate);
+    };
+    if (!timeOut || timeOut < slowPollThreshold) {
+        cy.GLO_getElement(selector, { timeout: timeOut }).should(($grid) => {
+            const tabCount = getTotalCount($grid);
+            if (tabCount !== null) {
+                runChainAssertion(tabCount);
+            }
+            else {
+                runChainAssertion($grid.find('.ag-center-cols-container [row-index]'));
+            }
+        });
+    }
+    else {
+        const maxAttempts = Math.max(1, Math.ceil(timeOut / pollInterval));
+        let attempts = 0;
+        let lastError;
+        const log = Cypress.log({ name: 'checkNumberOfRowsInGrid', message: `Polling rows (${lengthCondition} ${numberToValidate})…`, autoEnd: false, timeout: 0 });
+        const checkStatus = (resolve, reject) => {
+            cy.GLO_getElement(selector, { timeout: timeOut }).then(($grid) => {
+                const $rows = $grid.find('.ag-center-cols-container [row-index]');
+                let actual = $rows.length;
+                let passed = false;
+                try {
+                    const tabCount = getTotalCount($grid);
+                    if (tabCount !== null) {
+                        actual = tabCount;
+                        runChainAssertion(actual);
+                    }
+                    else {
+                        runChainAssertion($rows);
+                    }
+                    passed = true;
+                }
+                catch (e) {
+                    lastError = e;
+                    if (e.message.includes('Invalid Chai property')) {
+                        log.end();
+                        reject(e);
+                        return;
+                    }
+                }
+                if (passed) {
+                    cy.log(`SUCCESS: ${actual} to ${lengthCondition} ${numberToValidate}`);
+                    log.end();
+                    resolve();
+                    return;
+                }
+                attempts += 1;
+                if (attempts > maxAttempts) {
+                    log.end();
+                    cy.log(`FAILURE: ${actual} to ${lengthCondition} ${numberToValidate} after ${Math.round((maxAttempts * pollInterval) / 100) / 10}s, error: ${lastError?.message || 'unknown'}`);
+                    reject(new Error(`Timed out after ${Math.round((maxAttempts * pollInterval) / 100) / 10}s: row count was ${actual}, expected "${lengthCondition} ${numberToValidate}"`));
+                    return;
+                }
+                // biome-ignore plugin: wait for next poll interval before checking again
+                cy.wait(pollInterval, { log: false }).then(() => {
+                    log.set({ message: `Still polling ${actual} to ${lengthCondition} ${numberToValidate} ${attempts}/${maxAttempts}` });
+                    checkStatus(resolve, reject);
+                });
+            });
+        };
+        const promise = new Cypress.Promise((resolve, reject) => {
+            checkStatus(resolve, reject);
+        });
+        cy.then(() => promise);
+    }
+});
+Cypress.Commands.add('GLO_getNumberOfRowsInGrid', (selector, timeOut) => {
+    return cy.GLO_getAllRowsInGrid(selector, timeOut).its('length');
+});
+Cypress.Commands.add('GLO_clearField', (selector) => {
+    let loadingIndicator;
+    let skipCheck = false;
+    let zeroDefaultingField = false;
+    const { baseSelector, index } = extractSelectorParts(selector);
+    const inGrid = isGridRowSelector(baseSelector, index);
+    const effectiveSelector = inGrid ? selector : baseSelector;
+    const effectiveIndex = inGrid ? 0 : index;
+    const stringPartCount = baseSelector.filter((s) => typeof s === 'string').length;
+    const getElement = () => {
+        return stringPartCount >= 2 ? cy.GLO_getElement(effectiveSelector) : cy.GLO_getElement(effectiveSelector).find('.control-field');
+    };
+    const pressClearIcon = (field) => {
+        return cy.wrap(field, { log: false }).then(($el) => {
+            const $buttonContainers = $el.find('.dx-texteditor-buttons-container .dx-clear-button-area');
+            const $visibleContainer = $buttonContainers.filter((_, el) => {
+                return el.offsetWidth > 0 || el.offsetHeight > 0 || el.getClientRects().length > 0;
+            });
+            const $clearIcon = $visibleContainer.eq(effectiveIndex).find('.dx-icon-clear');
+            if ($clearIcon.length > 0) {
+                return cy
+                    .wrap($clearIcon, { log: false })
+                    .click({ force: true })
+                    .then(() => {
+                    loadingIndicator = true;
+                    return true;
+                });
+            }
+            return cy.wrap(false);
+        });
+    };
+    const clearInput = (element) => {
+        cy.wrap(element, { log: false }).then(($el) => {
+            const $input = $el.find('.dx-texteditor-input').eq(effectiveIndex);
+            const tag = String($input.prop('tagName')).toLowerCase();
+            if ($input.length === 0) {
+                cy.GLO_log('___No input found, add correct data-cy for clearing.___');
+                skipCheck = true;
+            }
+            else if (tag === 'input' && $input.val()) {
+                cy.wrap($input, { log: false }).type('{selectall}{del}{enter}');
+                loadingIndicator = true;
+            }
+            else {
+                cy.wrap($input, { log: false }).type('{selectall}{del}');
+            }
+        });
+    };
+    const processField = () => {
+        return getElement().then(($field) => {
+            // Some fields get cleared to 0 instead of to '' so we need to make sure the 'clearcheck' at the end of this command will correctly check vs 0 or ''.
+            const isDxNumberBox = $field.find('dx-number-box').length > 0;
+            const hasVisibleNumericInput = $field.find('.dx-texteditor-input[inputmode="decimal"]').length > 0;
+            zeroDefaultingField = isDxNumberBox && hasVisibleNumericInput;
+            pressClearIcon($field).then((hasIconButton) => {
+                if (!hasIconButton)
+                    clearInput($field);
+            });
+        });
+    };
+    const getAndProcessField = () => {
+        cy.log('___Clearing field___');
+        processField().then(() => {
+            if (loadingIndicator) {
+                cy.GLO_checkLoadingIndicator();
+            }
+            else if (!skipCheck) {
+                const expectedValue = zeroDefaultingField ? 0 : '';
+                cy.GLO_checkField(selector, expectedValue, equal, 30000);
+            }
+        });
+    };
+    getAndProcessField();
+});
+Cypress.Commands.add('GLO_readFile', (fileName, fileType) => {
+    cy.readFile(`${Cypress.config('downloadsFolder')}/${fileName}.${fileType}`);
+});
+Cypress.Commands.add('GLO_dialogRequiredCheck', (confirmation, title, content, contentMatchType = 'exact') => {
+    cy.GLO_getVisible('.svy-message-dialog, .svy-dialog', 120000).within(($dialog) => {
+        if ($dialog.find('.window-title.type-error:visible').length > 0) {
+            if (typeof title === 'undefined' && typeof content === 'undefined') {
+                cy.GLO_log('Error dialog, failing test. Explicit definition of the title or content required.');
+            }
+        }
+        if (title)
+            cy.get('.window-title').should('have.text', title);
+        if (content) {
+            cy.get('.window-body').then(($body) => {
+                const hasTextarea = $body.find('textarea').length > 0;
+                let matchType;
+                if (hasTextarea) {
+                    matchType = contentMatchType === 'partial' ? 'contain.value' : 'have.value';
+                }
+                else {
+                    matchType = contentMatchType === 'partial' ? 'contain.text' : 'have.text';
+                }
+                cy.get(hasTextarea ? '.window-body textarea' : '.window-body span').should(matchType, content);
+            });
+        }
+        cy.get('button').contains(confirmation).closest('button').click();
+    });
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_radioButton', (selector, selectorName) => {
+    if (selectorName === undefined)
+        return;
+    cy.GLO_getElement(selector).contains(selectorName).parent().find('.dx-radiobutton-icon').click();
+});
+Cypress.Commands.add('GLO_radioListCData', (selector, radioButtonName) => {
+    if (!radioButtonName)
+        return;
+    cy.GLO_getElement(selector)
+        .find('.dx-item-content')
+        .filter(`:contains("${String(radioButtonName)}")`)
+        .then(($element) => {
+        cy.wrap($element).parents('.dx-radiobutton').click();
+    });
+});
+Cypress.Commands.add('GLO_validateRadioListCData', (selector, radioButtonName, expectedState) => {
+    cy.GLO_getElement(selector)
+        .find('.dx-item-content')
+        .filter(`:contains("${radioButtonName}")`)
+        .then(($element) => {
+        if (expectedState) {
+            cy.wrap($element).parents('.dx-radiobutton').find('.dx-radiobutton-icon-dot').should('exist');
+        }
+        else {
+            cy.wrap($element).parents('.dx-radiobutton').find('.dx-radiobutton-icon-dot').should('not.exist');
+        }
+    });
+});
+Cypress.Commands.add('GLO_changeUserRole', (userRole) => {
+    cy.GLO_getElement(['ng$main_form2', 'navbar_top']).find('.lucide-User').click();
+    cy.get('.dx-menu-item-text').contains(userRole).click();
+    cy.GLO_dialogRequiredCheck('Yes');
+});
+Cypress.Commands.add('GLO_selectRows', (selector, rowNumber) => {
+    const executeForLoop = (rowNumber) => {
+        for (let i = 1; i < rowNumber; i++) {
+            cy.GLO_selectRowInGrid(i);
+        }
+    };
+    cy.GLO_getElement(selector)
+        .find('.ag-body-viewport')
+        .within(() => {
+        cy.GLO_clickRowInGrid(0); // Always click the first row
+        if (rowNumber !== undefined) {
+            executeForLoop(rowNumber);
+        }
+        else {
+            cy.GLO_getAllRowsInGrid().then(($rows) => {
+                executeForLoop($rows.length);
+            });
+        }
+    });
+});
+Cypress.Commands.add('GLO_sortGrid', (selector, headerText) => {
+    cy.GLO_getElement(selector)
+        .find('.ag-header-viewport .ag-header-row.ag-header-row-column')
+        .within(() => {
+        cy.get('.ag-header-cell').contains(headerText).click();
+    });
+    cy.GLO_checkAGLoader();
+});
+Cypress.Commands.add('GLO_fillInfieldInGrid', (selector, rowFilter, columnId, value, gridInputType = gridInput) => {
+    if (!value)
+        return;
+    if (typeof rowFilter === 'string') {
+        cy.GLO_getAllRowsInGrid().filter(`:contains("${rowFilter}")`).find(`[col-id="${columnId}"]`).click();
+        cy.GLO_getAllRowsInGrid().filter(`:contains("${rowFilter}")`).find(`[col-id="${columnId}"]`).dblclick();
+    }
+    else {
+        cy.GLO_getElement(selector).within(() => {
+            cy.GLO_clickRowInGrid(rowFilter, columnId);
+        });
+        cy.GLO_dblClickRowInGrid(row, selector, rowFilter, columnId, skipCheck);
+    }
+    cy.get(gridInputType === 'aggrid-texteditor-without-enter' ? gridInput : gridInputType, { timeout: 1000 }).should('exist');
+    switch (gridInputType) {
+        case gridInput:
+            cy.GLO_getVisible(gridInputType).type(`${String(value)}{enter}`);
+            break;
+        case gridInputWithoutEnter:
+            cy.GLO_getVisible(gridInput).type(String(value));
+            break;
+        case gridDropDown:
+            cy.GLO_getVisible('aggrid-typeahededitor input').type(String(value));
+            cy.GLO_getVisible('ngb-typeahead-window').find('button').contains(String(value)).click();
+            break;
+        case gridSelect:
+            cy.GLO_getVisible(`${gridSelect} select`).select(String(value)).type('{enter}');
+            break;
+        default:
+            throw new Error('Incorrect type for GLO_fillInfieldInGrid. Available types: gridInput, gridDropDown');
+    }
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_dropdownSelectFirstvalue', (selector) => {
+    cy.GLO_getElement(selector).within(() => {
+        cy.get('.dx-dropdowneditor-icon').click();
+    });
+    cy.GLO_getVisible('.dx-scrollview-content .dx-list-item').first().click();
+});
+Cypress.Commands.add('GLO_storeCurrentRecordId', (storeValueName) => {
+    cy.GLO_selectMenuButtonLeft('info');
+    cy.GLO_storeValue(['ng$svy_nav_globis_console_dlg', 'primary_key'], storeValueName);
+    cy.GLO_clickButton(['ng$svy_nav_globis_console_dlg', 'close_btn']);
+});
+Cypress.Commands.add('GLO_checkAndSelectCompany', (requestedCompanyCode) => {
+    cy.GLO_getElement(['ng$main_form2'], { timeout: 30000 })
+        .find('.footer span')
+        .contains('Company:')
+        .invoke('text')
+        .then((companyText) => {
+        const $currentCompanyCode = companyText.replace('Company:', '').trim();
+        if ($currentCompanyCode === requestedCompanyCode) {
+            cy.log(`Current company is ${$currentCompanyCode}. No switch required.`);
+        }
+        else {
+            cy.log(`Requested company is ${requestedCompanyCode}. Current company is ${$currentCompanyCode}. Switch required!`);
+            cy.GLO_switchCompany(requestedCompanyCode);
+            cy.log(`Company has been switched! Currently working on company ${requestedCompanyCode}`);
+        }
+    });
+});
+Cypress.Commands.add('GLO_selectAllGrid', (selector) => {
+    cy.GLO_getElement(selector).within(() => {
+        cy.GLO_getRowInGrid(0).find('[col-id]').eq(2).rightclick();
+    });
+    cy.get('a').contains('Select all', { matchCase: false }).click();
+});
+Cypress.Commands.add('GLO_clickButtonInGrid', { prevSubject: ['optional', 'element'] }, (subject, buttonColumn, rowFilter, validationColumn, x = 10, y = 50) => {
+    const getRow = () => {
+        if (subject) {
+            if (rowFilter !== undefined)
+                throw new Error('Cannot use rowFilter when chained!');
+            return cy.wrap(subject);
+        }
+        else if (rowFilter !== undefined) {
+            return cy.GLO_getRowInGrid(rowFilter);
+        }
+        else {
+            return cy.GLO_getVisible('[row-index]').first();
+        }
+    };
+    if (validationColumn) {
+        getRow()
+            .find(`[col-id="${validationColumn}"]`)
+            .invoke('text')
+            .then((text) => cy.wrap(text.trim()).as('beforeValue'));
+    }
+    getRow()
+        .find(`[col-id="${buttonColumn}"]`)
+        .then(($btn) => {
+        const xCor = ($btn.width() * x) / 100;
+        const yCor = ($btn.height() * y) / 100;
+        getRow().find(`[col-id="${buttonColumn}"]`).click(xCor, yCor);
+    });
+    if (validationColumn) {
+        cy.get('@beforeValue').then((beforeValue) => {
+            getRow()
+                .find(`[col-id="${validationColumn}"]`, { timeout: 30000 })
+                .should(($afterValue) => {
+                expect($afterValue.text().trim()).not.to.equal(beforeValue);
+            });
+        });
+    }
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_oktaAlternativeLogin', (altUser, company) => {
+    cy.GLO_logout();
+    // biome-ignore plugin: wait for Okta to process logout
+    cy.wait(10000); // Wait for Okta to process logout
+    if (cypressWebsocketLoader) {
+        cy.on('window:before:load', (win) => {
+            attachWebSocketSpy(win);
+        });
+    }
+    if (altUser) {
+        cy.origin(Cypress.expose('oktaUrl'), () => {
+            cy.get('.okta-container', { timeout: 120000 });
+            cy.get('.o-form-input', { timeout: 60000 })
+                .find('[autocomplete="username"]')
+                .clear()
+                .type(Cypress.expose('username2'));
+            cy.task('log', 'Filled in username');
+            cy.get('[type="submit"]').click();
+            cy.env(['password2']).then(({ password2 }) => {
+                cy.get('.o-form-input')
+                    .find('[type="password"]', { timeout: 20000 })
+                    .type(password2, { log: false });
+            });
+            cy.task('log', 'Filled in password');
+            cy.get('[type="submit"]').click();
+        });
+        cy.GLO_log(`Logged in as ${Cypress.expose('username2')}`);
+    }
+    else {
+        cy.origin(Cypress.expose('oktaUrl'), () => {
+            cy.get('.okta-container', { timeout: 120000 });
+            cy.get('.o-form-input', { timeout: 60000 })
+                .find('[autocomplete="username"]')
+                .clear()
+                .type(Cypress.expose('username'));
+            cy.task('log', 'Filled in username');
+            cy.get('[type="submit"]').click();
+            cy.env(['password']).then(({ password }) => {
+                cy.get('.o-form-input')
+                    .find('[type="password"]', { timeout: 20000 })
+                    .type(password, { log: false });
+            });
+            cy.task('log', 'Filled in password');
+            cy.get('[type="submit"]').click();
+        });
+        cy.GLO_log(`Logged in as ${Cypress.expose('username')}`);
+    }
+    if (cypressWebsocketLoader)
+        waitForWebSocketAfterOkta();
+    cy.get('[data-cy$="ng$main_form2.navbar_top"]', { timeout: 120000 }).should('exist');
+    if (company)
+        cy.GLO_checkAndSelectCompany(company);
+});
+Cypress.Commands.add('GLO_getAllRowsInGrid', (selector, timeOut = defaultTimeout) => {
+    if (selector) {
+        const deadline = Date.now() + timeOut;
+        return cy
+            .GLO_getElement(selector, { timeout: timeOut })
+            .find('.ag-center-cols-container [row-index]', { timeout: timeOut + 500 })
+            .should(($rows) => {
+            if ($rows.length === 0 && Date.now() < deadline)
+                throw new Error('GLO_getAllRowsInGrid: waiting for rows');
+        });
+    }
+    else {
+        return cy.get('.ag-center-cols-container [row-index] [role="gridcell"]', { timeout: timeOut }).parent().filter(isInOpenContainer);
+    }
+});
+Cypress.Commands.add('GLO_validateGridOrFail', (waitValue, failValue, rowNumber, columnId, timeOut = 600000, interval = 15000) => {
+    validateGridValue(waitValue, failValue, rowNumber, columnId, timeOut, interval);
+});
+const validateGridValue = (value, failValue, rowFilter, columnId, timeOut = 10000, interval, operator = contains) => {
+    const assertOrCheckCellValue = ($cells, toCheck, doAssert) => {
+        const compare = (cellText) => {
+            const text = cellText.trim();
+            const normalizedValue = typeof toCheck === 'number' ? toCheck : String(toCheck).trim();
+            const inputVal = typeof normalizedValue === 'number' ? parseLocalizedNumber(text) : text;
+            if (operator === equal) {
+                return inputVal === normalizedValue;
+            }
+            else if (operator === notEqual) {
+                return inputVal !== normalizedValue;
+            }
+            else if (operator === contains) {
+                return String(inputVal).includes(String(normalizedValue));
+            }
+            else if (operator === greaterEqual && typeof inputVal === 'number' && typeof normalizedValue === 'number') {
+                return inputVal >= normalizedValue;
+            }
+            throw new Error('Incorrect operator for GLO_checkField. Available operators: equal, notEqual, contains, greaterEqual');
+        };
+        const match = $cells.toArray().find((cell) => compare(cell.textContent));
+        const found = !!match;
+        if (doAssert)
+            assert.isTrue(found, `Cell value "${operator}" "${String(toCheck)}"`);
+        return found;
+    };
+    const toCheckData = () => {
+        const logOpt = { log: !interval };
+        if (columnId && rowFilter !== undefined)
+            return typeof rowFilter === 'number'
+                ? cy
+                    .GLO_getAllRowsInGrid(undefined, timeOut)
+                    .find(`[col-id="${columnId}"]`, logOpt)
+                    .eq(rowFilter, { timeout: timeOut, ...logOpt })
+                : cy
+                    .GLO_getAllRowsInGrid(undefined, timeOut)
+                    .filter(`:contains("${rowFilter}")`, { timeout: timeOut, ...logOpt })
+                    .find(`[col-id="${columnId}"]`, logOpt);
+        else if (columnId)
+            return cy.GLO_getAllRowsInGrid(undefined, timeOut).find(`[col-id="${columnId}"]`, { timeout: timeOut, ...logOpt });
+        else if (rowFilter !== undefined)
+            return (typeof rowFilter === 'number'
+                ? cy.GLO_getAllRowsInGrid(undefined, timeOut).eq(rowFilter, { timeout: timeOut, ...logOpt })
+                : cy.GLO_getAllRowsInGrid(undefined, timeOut).filter(`:contains("${rowFilter}")`, { timeout: timeOut, ...logOpt })).find('.ag-cell-value');
+        else
+            return cy.GLO_getAllRowsInGrid(undefined, timeOut);
+    };
+    if (Array.isArray(value)) {
+        if (columnId)
+            throw new Error('Cannot use combination of array and column id');
+        const spansArray = value.map((span) => span.trim());
+        const filterSelector = spansArray.map((span) => `:has(span:contains("${span}"))`).join('');
+        if (rowFilter !== undefined)
+            cy.GLO_getRowInGrid(rowFilter).filter(filterSelector, { timeout: timeOut }).should('exist');
+        else
+            cy.GLO_getAllRowsInGrid().filter(filterSelector, { timeout: timeOut }).should('exist');
+    }
+    else if (!interval) {
+        toCheckData().should(($cells) => assertOrCheckCellValue($cells, value, true));
+    }
+    else {
+        const pollInterval = interval;
+        const maxAttempts = Math.max(1, Math.ceil(timeOut / pollInterval));
+        let attempts = 0;
+        const log = Cypress.log({ name: 'gridValueValidator', message: `Polling for "${String(value)}"…`, autoEnd: false, timeout: 0 });
+        const checkStatus = (resolve, reject) => {
+            toCheckData().then(($cells) => {
+                if (failValue !== undefined && assertOrCheckCellValue($cells, failValue, false)) {
+                    cy.log(`Found fail value: ${String(failValue)}`);
+                    log.end();
+                    reject(new Error(`Found fail value: ${String(failValue)}`));
+                    return;
+                }
+                if (assertOrCheckCellValue($cells, value, false)) {
+                    cy.log(`Succeeded finding "${String(value)}"`);
+                    log.end();
+                    resolve();
+                    return;
+                }
+                attempts += 1;
+                if (attempts >= maxAttempts) {
+                    cy.log(`Timed out after ${Math.round((maxAttempts * pollInterval) / 100) / 10}s waiting for: ${String(value)}`);
+                    log.end();
+                    reject(new Error(`Timed out after ${Math.round((maxAttempts * pollInterval) / 100) / 10}s waiting for: ${String(value)}`));
+                    return;
+                }
+                cy.wait(pollInterval, { log: false }).then(() => {
+                    log.set({ message: `Still polling… ${attempts}/${maxAttempts}` });
+                    checkStatus(resolve, reject);
+                });
+            });
+        };
+        const promise = new Cypress.Promise((resolve, reject) => {
+            checkStatus(resolve, reject);
+        });
+        cy.then(() => promise);
+    }
+};
+Cypress.Commands.add('GLO_getCurrentRecordCount', () => {
+    return cy
+        .GLO_getElement(['ng$datacontrol', 'datacontrol'])
+        .find('#txtCount')
+        .invoke('text')
+        .then((records) => {
+        const [currentStr, totalStr] = records.split('/');
+        if (!currentStr || !totalStr) {
+            throw new Error(`Could not parse record count from "${records}"`);
+        }
+        return {
+            currentRecord: parseInt(currentStr.trim(), 10),
+            totalRecords: parseInt(totalStr.trim(), 10)
+        };
+    });
+});
+Cypress.Commands.add('GLO_storeObject', (formName, elementNames, index, log = hideInCommandLog) => {
+    const keys = (Array.isArray(elementNames) ? elementNames : [elementNames]);
+    // Initialize saveData object to prevent cypress from failing when saving first alias.
+    cy.then(() => {
+        const current = Cypress.expose('saveData') ?? {};
+        Cypress.expose('saveData', current);
+        cy.wrap(current, { log: false }).as('saveData');
+    });
+    // The actual storing of values.
+    cy.wrap(keys, { log: false }).each((key) => {
+        cy.GLO_getElement([formName, key])
+            .find('.dx-texteditor-input', { log: false })
+            .invoke('val')
+            .then((text) => {
+            const value = String(text);
+            const saveData = Cypress.expose('saveData') ?? {};
+            // Create the nested object if it doesn't exist yet.
+            saveData[formName] ??= {};
+            if (typeof index === 'number') {
+                const existing = saveData[formName][key];
+                // Determine if we need to create a new array or use the existing one.
+                const arr = Array.isArray(existing) ? existing : [];
+                arr[index] = value;
+                saveData[formName][key] = arr;
+            }
+            else {
+                saveData[formName][key] = value;
+            }
+            Cypress.expose('saveData', saveData);
+            cy.wrap(saveData, { log: false }).as('saveData');
+            const indexSuffix = typeof index === 'number' ? `[${index}]` : '';
+            if (log)
+                cy.GLO_log(`Value saved at saveData.${formName}.${key}${indexSuffix}: ${value}`);
+        });
+    });
+});
+Cypress.Commands.add('GLO_checkFieldInvalid', (selector, shouldBeInvalid = isInvalid) => {
+    cy.GLO_getElement(selector).within(() => {
+        if (shouldBeInvalid) {
+            cy.get('.dx-texteditor').should('have.class', 'dx-invalid');
+        }
+        else {
+            cy.get('.dx-texteditor').should('not.have.class', 'dx-invalid');
+        }
+    });
+});
+Cypress.Commands.add('GLO_checkFieldEnabled', (selector, shouldBeEnabled = enabled) => {
+    cy.GLO_getElement(selector).within(() => {
+        if (shouldBeEnabled) {
+            cy.get('.dx-texteditor').should('not.have.class', 'dx-state-disabled');
+        }
+        else {
+            cy.get('.dx-texteditor').should('have.class', 'dx-state-disabled');
+        }
+    });
+});
+Cypress.Commands.add('GLO_checkFieldBgColor', (selector, color = 'red') => {
+    const [formName, fieldOrFields] = selector;
+    const fields = Array.isArray(fieldOrFields) ? fieldOrFields : [fieldOrFields];
+    for (const field of fields) {
+        cy.GLO_getElement([formName, field]).within(() => {
+            cy.get('input.dx-texteditor-input').should('have.class', `input_bg_${color}`);
+        });
+    }
+});
+Cypress.Commands.add('GLO_extendedFilter', (filter, clearExistingFilters) => {
+    // **************
+    // * Selectors *
+    // **************
+    const filterComponent = () => cy.GLO_getElement(['ng$extended_filter', 'Extended_Filter_Builder'], { log: false });
+    const getFilterFieldSelector = (path, fieldType, clauseType, includeInputClass = true) => {
+        const prefix = clauseType
+            ? { Attribute: 'clause-', 'Related field': 'relation-', 'Dynamic attribute': 'clause-', Group: 'group-', 'Nested group': 'group-' }[clauseType] || ''
+            : '';
+        return `[data-cy="filter-builder-${fieldType === 'value' ? '' : prefix}${fieldType}-${path}"]${includeInputClass ? ' .dx-texteditor-input' : ''}`;
+    };
+    // **************
+    // * Buttons    *
+    // **************
+    const buttonClearall = () => filterComponent().find('[data-cy="filter-builder-clear-all"]').click();
+    const buttonRunquery = () => filterComponent().find('[data-cy="filter-builder-run-query"]').should('not.be.disabled').click();
+    const buttonAdd = (filterType, groupPath) => {
+        const click = (buttonType) => {
+            const prefix = groupPath ? `filter-builder-group-${groupPath}-` : 'filter-builder-';
+            return filterComponent().find(`[data-cy="${prefix}${buttonType}"]`).click();
+        };
+        switch (filterType) {
+            case 'Related field':
+                return click('add-related-field');
+            case 'Dynamic attribute':
+                return click('add-dynamic-attribute');
+            case 'Nested group':
+                if (!groupPath)
+                    throw new Error('Nested group can only be added inside a group');
+                return click('add-nested-group');
+            case 'Group':
+                return groupPath ? click('add-nested-group') : click('add-group');
+            default:
+                return click('add-attribute');
+        }
+    };
+    // **************
+    // * Inputs     *
+    // **************
+    const dropDown = (path, clauseType, dropDownType, value) => {
+        const selector = getFilterFieldSelector(path, dropDownType, clauseType);
+        filterComponent()
+            .find(selector)
+            .then(($el) => {
+            const id = $el[0].getAttribute('aria-controls');
+            if (!id)
+                cy.wrap($el).click();
+        });
+        filterComponent()
+            .find(selector)
+            .then(($el) => {
+            const id = $el[0].getAttribute('aria-controls');
+            if (!id)
+                throw new Error('Missing aria-controls');
+            cy.get(`[id="${id}"]`, { timeout: 30000 }).should('exist').should('not.have.class', 'dx-empty-collection').find('.dx-item').should('have.length.greaterThan', 0);
+            cy.get(`[id="${id}"] .dx-scrollview-content`).children().contains(value).click();
+        });
+        switch (dropDownType) {
+            case 'select':
+                filterComponent()
+                    .find(getFilterFieldSelector(path, dropDownType, clauseType, false))
+                    .parent()
+                    .find('.dx-tag button')
+                    .filter((_, el) => (el.getAttribute('aria-label') ?? '').includes(value))
+                    .should('have.length.greaterThan', 0);
+                break;
+            case 'value':
+                if (value === 'Select All')
+                    return;
+                filterComponent()
+                    .find(`${getFilterFieldSelector(path, dropDownType, clauseType, false)} .dx-tag`)
+                    .filter((_, el) => (el.getAttribute('aria-label') ?? '').includes(value))
+                    .should('have.length.greaterThan', 0);
+                break;
+            case 'field':
+            case 'logical-operator':
+            case 'operator':
+                filterComponent().find(selector).invoke('val').should('include', value);
+                break;
+            default:
+                break;
+        }
+    };
+    // This is basically the same as checkBoxHelper but adapted for the selector inside the extended filter component.
+    const checkBox = (path, v) => {
+        const retries = 3;
+        const clickElement = (remaining = retries) => {
+            return filterComponent()
+                .find(getFilterFieldSelector(path, 'value', undefined, false))
+                .then(($element) => {
+                const currentState = $element[0].getAttribute('aria-checked');
+                if (currentState === v)
+                    return;
+                if (remaining <= 0)
+                    throw new Error('Failed to set checkbox/switch to the desired state after multiple attempts.');
+                filterComponent()
+                    .find(getFilterFieldSelector(path, 'value', undefined, false))
+                    .find('.dx-checkbox-icon')
+                    .click()
+                    .then(() => {
+                    cy.GLO_checkLoadingIndicator();
+                    clickElement(remaining - 1);
+                });
+            });
+        };
+        clickElement();
+    };
+    const applyValueForOperator = (operator, path, clauseType, values) => {
+        const vals = Array.isArray(values) ? values : [values];
+        vals.forEach((v, i) => {
+            switch (operator) {
+                case 'is empty':
+                case 'is not empty':
+                case 'today':
+                case 'this week':
+                case 'this month':
+                    return;
+                case 'between':
+                    filterComponent()
+                        .find(getFilterFieldSelector(path, `value-${i === 0 ? 'from' : 'to'}`))
+                        .type(`{selectall}{del}${v}{enter}`);
+                    return;
+                case 'in':
+                case 'not in':
+                    filterComponent()
+                        .find(getFilterFieldSelector(path, 'value', undefined, false))
+                        .parent()
+                        .then(($field) => {
+                        if ($field.find('button.fa-search').length > 0) {
+                            if (i >= 1)
+                                throw new Error('Selector only supports a single value (for now).');
+                            cy.wrap($field).find('button.fa-search').click();
+                            cy.GLO_getElement(['svy_nav_selection', 'search_criteria']).type(String(v));
+                            cy.GLO_clickButton(['svy_nav_selection', 'btn_search']);
+                            dblClickRowInGrid(span, String(v));
+                            cy.GLO_checkLoadingIndicator();
+                        }
+                        else {
+                            dropDown(path, clauseType, 'value', String(v));
+                            if (i === vals.length - 1)
+                                filterComponent()
+                                    .find(getFilterFieldSelector(path, 'value', clauseType))
+                                    .click();
+                        }
+                    });
+                    return;
+                case '=':
+                // biome-ignore lint/suspicious/noFallthroughSwitchClause: intentional - falls through to the shared date/time handling below when v isn't check/uncheck
+                case '≠':
+                    if (v === check || v === unCheck) {
+                        checkBox(path, v);
+                        return;
+                    }
+                // Fall through
+                case 'before':
+                case 'after':
+                case '<= today +/- days':
+                case '>= today +/- days':
+                case 'contains':
+                case 'starts with':
+                case 'ends with':
+                case '>':
+                case '>=':
+                case '<':
+                case '<=':
+                    filterComponent().find(getFilterFieldSelector(path, 'value')).type(`{selectall}{del}${v}{enter}`);
+                    return;
+                default: {
+                    const _exhaustive = operator;
+                    throw new Error(`Unhandled operator: ${String(_exhaustive)}`);
+                }
+            }
+        });
+    };
+    const applyLeaf = (leaf, path, parentGroupPath, isFirstRoot) => {
+        const clauseType = leaf.type ?? 'Attribute';
+        if (parentGroupPath)
+            buttonAdd(clauseType, parentGroupPath);
+        else {
+            if (isFirstRoot && clauseType !== 'Attribute')
+                filterComponent().find('[data-cy="filter-builder-clause-remove-0"]').click();
+            if (!isFirstRoot || clauseType !== 'Attribute')
+                buttonAdd(clauseType);
+        }
+        leaf.logicalOperator && !isFirstRoot && dropDown(path, clauseType, 'logical-operator', leaf.logicalOperator);
+        if (leaf.type === 'Related field')
+            (Array.isArray(leaf.relationSelect) ? leaf.relationSelect : [leaf.relationSelect]).forEach((v, i) => {
+                dropDown(path, clauseType, 'select', v);
+                if (i !== leaf.relationSelect.length - 1)
+                    filterComponent()
+                        .find(getFilterFieldSelector(path, 'select', clauseType))
+                        .click();
+            });
+        dropDown(path, clauseType, 'field', leaf.field);
+        dropDown(path, clauseType, 'operator', leaf.operator);
+        if (!('values' in leaf))
+            return;
+        applyValueForOperator(leaf.operator, path, clauseType, leaf.values);
+    };
+    const applyNode = (node, path, parentGroupPath, isFirstRoot) => {
+        const isGroup = (n) => n.type === 'Group';
+        const isNestedGroup = (n) => n.type === 'Nested group';
+        if (isGroup(node)) {
+            if (parentGroupPath)
+                buttonAdd('Group', parentGroupPath);
+            else {
+                if (isFirstRoot)
+                    filterComponent().find('[data-cy="filter-builder-clause-remove-0"]').click();
+                buttonAdd('Group');
+            }
+            node.logicalOperator && dropDown(path, 'Group', 'logical-operator', node.logicalOperator);
+            node.values.forEach((child, i) => {
+                applyNode(child, `${path}-${i}`, path, false);
+            });
+            return;
+        }
+        if (isNestedGroup(node)) {
+            if (!parentGroupPath)
+                throw new Error('Nested group requires a parent group');
+            buttonAdd('Nested group', parentGroupPath);
+            node.logicalOperator && dropDown(path, 'Nested group', 'logical-operator', node.logicalOperator);
+            node.values.forEach((child, i) => {
+                applyNode(child, `${path}-${i}`, path, false);
+            });
+            return;
+        }
+        applyLeaf(node, path, parentGroupPath, isFirstRoot);
+    };
+    cy.get('div[id^="crumb_"]:not([hidden])', { log: false }).then(($crumbRoot) => {
+        $crumbRoot.find('[data-cy="ng$extended_filter.Extended_Filter_Builder"]').length === 0 && cy.GLO_clickDatacontrolBrowserButton('btnFilter');
+    });
+    if (clearExistingFilters)
+        buttonClearall();
+    filter.forEach((node, i) => {
+        applyNode(node, `${i}`, undefined, i === 0);
+    });
+    buttonRunquery();
+    cy.GLO_checkLoadingIndicator();
+});
+Cypress.Commands.add('GLO_selectNamedSearch', (searchName) => {
+    cy.GLO_clickDatacontrolBrowserButton('btnExtendedSearch');
+    cy.GLO_getVisible('.dx-submenu', 10000).contains(searchName).click();
+    cy.GLO_checkLoadingIndicator();
+});