@globisnv/cypress-core 0.0.10 → 1.1.0

package/dist/websocketDetector.js

@@ -497,66 +497,86 @@ Cypress.Commands.add('WS_loadingCheck', (options) => {
         });
         return cy.wrap('locked', { log: false });
     }
-    // ═══════════════════════════════════════════════════════════════════════════
-    // Main polling loop
-    // ═══════════════════════════════════════════════════════════════════════════
-    /** Entry point for the resolution loop. Polls every 100 ms until resolved or timed out. */
+    /**
+     * Entry point for the resolution loop.
+     *
+     * The poll body only *reads* synchronous state (`win.wsMessages`, `state`, the AUT DOM via
+     * `Cypress.$`), so it runs in a plain `setInterval` inside a single command-queue entry — stack
+     * depth stays constant however long we wait. The old loop recursed through `cy.wait().then(checkAndWait)`,
+     * nesting one chainer per 100 ms; under the 20-min ceiling that exhausted V8's stack before
+     * handleTimeout() could ever fire. Only the dialog auto-click needs queued cy commands, so it is
+     * returned as a 'dialog' outcome and performed in a follow-up .then() before re-entering the poll.
+     */
     function waitForResolution() {
         const startTime = Date.now();
-        return checkAndWait();
-        function checkAndWait() {
+        // The .then() awaits the poll promise, so its command timeout must outlast the longest
+        // possible poll — otherwise Cypress aborts before pollOnce() reaches its own timeout branch.
+        const pollCommandTimeout = (options?.timeout ? config.timeout : Math.max(1200000, config.timeout)) + 60000;
+        return runPoll();
+        function runPoll() {
             return cy
                 .window({ log: false })
-                .then((win) => {
-                let hasWsMessages;
-                try {
-                    hasWsMessages = !!win.wsMessages;
-                }
-                catch {
-                    hasWsMessages = false;
-                }
-                // If wsMessages is gone the page navigated away — nothing more to wait for
-                if (!hasWsMessages)
-                    return cy.wrap('navigated', { log: false });
-                return checkForDialogs();
+                .then({ timeout: pollCommandTimeout }, (win) => {
+                return new Cypress.Promise((resolve) => {
+                    let settled = false;
+                    let intervalId = null;
+                    const finish = (outcome) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        if (intervalId !== null)
+                            clearInterval(intervalId);
+                        resolve(outcome);
+                    };
+                    const tick = () => {
+                        try {
+                            const outcome = pollOnce(win);
+                            if (outcome)
+                                finish(outcome);
+                        }
+                        catch (error) {
+                            finish({ type: 'error', error });
+                        }
+                    };
+                    tick(); // check immediately, then every 100 ms
+                    if (!settled)
+                        intervalId = setInterval(tick, 100);
+                });
             })
-                .then((dialogType) => {
-                if (dialogType === 'navigated') {
-                    debugLog('🟢 Page navigated away — resolving loader');
-                    log.set({ displayName: '🟢 WSLoader', message: 'Resolved' }).end();
-                    return cy.wrap(undefined, { log: false });
-                }
-                if (dialogType === 'locked') {
-                    debugLog('🔓 Resolving loader due to locked record detection');
-                    log.set({ displayName: '🟡 WSLoader', message: 'Resolved (Locked Record)' }).end();
-                    return clearWebSocketMessages();
-                }
-                return performResolutionCheck();
-            });
+                .then((outcome) => dispatch(outcome));
         }
-        function performResolutionCheck() {
-            return checkResolution().then((isResolved) => {
-                if (isResolved)
-                    return handleResolvedState();
-                const effectiveTimeout = !options?.timeout && domLoadingIndicatorEverDetected ? 1200000 : config.timeout;
-                if (Date.now() - startTime > effectiveTimeout)
-                    return handleTimeout(effectiveTimeout);
-                // biome-ignore plugin: internal polling interval for checkAndWait retry loop
-                return cy.wait(100, { log: false }).then(() => checkAndWait());
-            });
-        }
-        /**
-         * Called once isStateResolved() returns true.
-         * Enforces the quiet period — the state must stay resolved for QUIET_PERIOD_MS before
-         * we actually commit to being done.
-         */
-        function handleResolvedState() {
-            if (state.navigatingAway) {
-                log.set({ displayName: '🟢 WSLoader', message: 'Resolved (navigation)' }).end();
-                return clearWebSocketMessages();
+        /** One synchronous poll tick. Returns an outcome to act on, or null to keep polling. */
+        function pollOnce(win) {
+            let wsMessages;
+            try {
+                wsMessages = win.wsMessages;
+            }
+            catch {
+                wsMessages = undefined;
+            }
+            // wsMessages gone → the page navigated away, nothing more to wait for
+            if (!wsMessages)
+                return { type: 'navigated' };
+            const effectiveTimeout = !options?.timeout && domLoadingIndicatorEverDetected ? 1200000 : config.timeout;
+            const timedOut = Date.now() - startTime > effectiveTimeout;
+            // A dialog we auto-dismiss needs queued cy commands — hand back to the follow-up, unless
+            // we're already over budget (fall through so handleTimeout() gets to dump its diagnostics).
+            // Cross-origin redirects (e.g. Okta) can flip win.document's origin between ticks, so this
+            // read throws — treat that the same as the wsMessages check above: page navigated away.
+            try {
+                if (!timedOut && dialogNeedsHandling(win))
+                    return { type: 'dialog' };
+                if (!checkDomReadySync(win.document))
+                    return timedOut ? { type: 'timeout', timeout: effectiveTimeout } : null;
+            }
+            catch {
+                return state.navigatingAway ? { type: 'resolved', reason: 'navigation' } : { type: 'navigated' };
             }
-            // Inside a popup that was opened before this loader started, use the longer quiet
-            // period to bridge the gap between the loading indicator hiding and executeEvent firing
+            if (!checkWsResolvedSync(win))
+                return timedOut ? { type: 'timeout', timeout: effectiveTimeout } : null;
+            // Resolved — enforce the quiet period before committing.
+            if (state.navigatingAway)
+                return { type: 'resolved', reason: 'navigation' };
             const isInsideExternalPopup = !state.popupOpenedByThisAction && currentWin?.wsPopupFormOpen === true;
             let quietPeriodMs;
             if (isInsideExternalPopup || expectSearchPopup) {
@@ -568,69 +588,54 @@ Cypress.Commands.add('WS_loadingCheck', (options) => {
             else {
                 quietPeriodMs = config.quietPeriodMs ?? QUIET_PERIOD_DEFAULT_MS;
             }
-            // Only resolve if quiet period has fully elapsed since the last WS activity
-            const now = Date.now();
-            const quietTimeSoFar = now - state.lastWsActivityTs;
-            const remaining = quietPeriodMs - quietTimeSoFar;
-            if (remaining > 0) {
-                return cy.wait(remaining, { log: false }).then(() => checkAndWait());
-            }
+            // Keep ticking until the state has stayed resolved for the full quiet period since last WS activity
+            if (quietPeriodMs - (Date.now() - state.lastWsActivityTs) > 0)
+                return null;
             state.extendedQuietPeriod = false;
-            log.set({ displayName: '🟢 WSLoader', message: 'Resolved' }).end();
-            return clearWebSocketMessages();
+            return { type: 'resolved' };
         }
-        /**
-         * Checks whether the DOM loading indicator is gone first, then checks WS state.
-         * The DOM indicator guards against Angular render lag that can appear after WS goes idle.
-         */
-        function checkResolution() {
-            return checkDomLoadingIndicator().then((domReady) => {
-                if (!domReady)
-                    return cy.wrap(false, { log: false });
-                return checkWsResolution();
-            });
+        /** Acts on a poll outcome, running any queued cy work, then finishes or re-enters the poll. */
+        function dispatch(outcome) {
+            switch (outcome.type) {
+                case 'navigated':
+                    debugLog('🟢 Page navigated away — resolving loader');
+                    log.set({ displayName: '🟢 WSLoader', message: 'Resolved' }).end();
+                    return cy.wrap(undefined, { log: false });
+                case 'dialog':
+                    return checkForDialogs().then((dialogType) => {
+                        if (dialogType === 'locked') {
+                            debugLog('🔓 Resolving loader due to locked record detection');
+                            log.set({ displayName: '🟡 WSLoader', message: 'Resolved (Locked Record)' }).end();
+                            return clearWebSocketMessages();
+                        }
+                        // Info/No-price OK-click enqueued (or the dialog vanished) — re-enter the flat poll
+                        return runPoll();
+                    });
+                case 'resolved':
+                    log.set({ displayName: '🟢 WSLoader', message: outcome.reason === 'navigation' ? 'Resolved (navigation)' : 'Resolved' }).end();
+                    return clearWebSocketMessages();
+                case 'timeout':
+                    return handleTimeout(outcome.timeout);
+                case 'error':
+                    throw outcome.error;
+            }
         }
-        /** Processes new WS frames and evaluates isStateResolved() in a single cy.window() call. */
-        function checkWsResolution() {
-            return cy.window({ log: false }).then((win) => {
-                currentWin = win;
-                let wsMessages;
-                try {
-                    wsMessages = win.wsMessages;
-                }
-                catch {
-                    wsMessages = undefined;
-                }
-                if (!wsMessages) {
-                    debugLog('🟢 No wsMessages found, resolving');
-                    return cy.wrap(true, { log: false });
-                }
-                processMessages(wsMessages);
-                const isResolved = isStateResolved();
-                let wsPopupFormOpen;
-                try {
-                    wsPopupFormOpen = win.wsPopupFormOpen ?? false;
-                }
-                catch {
-                    wsPopupFormOpen = false;
-                }
-                if (!isResolved && !state.popupOpenedByThisAction && wsPopupFormOpen) {
-                    debugLog('🪟 Inside popup from previous action — using extended quiet period');
-                }
-                updateLog(isResolved, startTime);
-                return cy.wrap(isResolved, { log: false });
-            });
+        // ── Synchronous per-tick checks (no queued cy commands) ──────────────────────────────────
+        /** True when a dialog is present that the loader auto-dismisses (the dismiss needs queued cy commands). */
+        function dialogNeedsHandling(win) {
+            const dialog = findDialog(win.document);
+            if (!dialog.exists)
+                return false;
+            if (dialog.isLocked)
+                return !lockedRecordDialogDetected;
+            if (dialog.isNoPrice)
+                return true;
+            if (dialog.isInfo)
+                return !!(config.enableAutoInfoDialog ?? wsDialogHandlerEnabled);
+            return false;
         }
-    }
-    // ═══════════════════════════════════════════════════════════════════════════
-    // DOM loading indicator check
-    // ═══════════════════════════════════════════════════════════════════════════
-    /**
-     * Returns false (not ready) while a `<loading-indicator>` element is present in the DOM.
-     * Updates a live Cypress log entry showing how long we have been waiting.
-     */
-    function checkDomLoadingIndicator() {
-        return cy.document({ log: false }).then((doc) => {
+        /** Synchronous form of checkDomLoadingIndicator — returns false while a loading-indicator is in the DOM. */
+        function checkDomReadySync(doc) {
             const hasLoadingIndicator = Cypress.$(doc.body).find('loading-indicator').length > 0;
             if (hasLoadingIndicator) {
                 if (state.domLoadingIndicatorStart === null) {
@@ -656,8 +661,37 @@ Cypress.Commands.add('WS_loadingCheck', (options) => {
                 state.domLoadingIndicatorStart = null;
                 domLoadingIndicatorLog = null;
             }
-            return cy.wrap(!hasLoadingIndicator, { log: false });
-        });
+            return !hasLoadingIndicator;
+        }
+        /** Synchronous form of checkWsResolution — processes new frames and returns isStateResolved(). */
+        function checkWsResolvedSync(win) {
+            currentWin = win;
+            let wsMessages;
+            try {
+                wsMessages = win.wsMessages;
+            }
+            catch {
+                wsMessages = undefined;
+            }
+            if (!wsMessages) {
+                debugLog('🟢 No wsMessages found, resolving');
+                return true;
+            }
+            processMessages(wsMessages);
+            const isResolved = isStateResolved();
+            let wsPopupFormOpen;
+            try {
+                wsPopupFormOpen = win.wsPopupFormOpen ?? false;
+            }
+            catch {
+                wsPopupFormOpen = false;
+            }
+            if (!isResolved && !state.popupOpenedByThisAction && wsPopupFormOpen) {
+                debugLog('🪟 Inside popup from previous action — using extended quiet period');
+            }
+            updateLog(isResolved, startTime);
+            return isResolved;
+        }
     }
     // ═══════════════════════════════════════════════════════════════════════════
     // Message processing

package/package.json

@@ -1,9 +1,12 @@
 {
     "name": "@globisnv/cypress-core",
-    "version": "0.0.10",
+    "version": "1.1.0",
     "description": "Core building blocks for Globis Cypress E2E tests",
     "license": "UNLICENSED",
     "type": "module",
+    "engines": {
+        "node": "^22.0.0 || ^24.0.0 || >=26.0.0"
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/globisnv/globis-cypress-core.git"
@@ -43,8 +46,8 @@
         "typescript": "tsc --noEmit --skipLibCheck"
     },
     "peerDependencies": {
-        "cypress": "^15.20.1",
-        "cypress-real-events": "^1.15.0"
+        "cypress": "^16.0.0",
+        "cypress-real-events": "^1.15.1"
     },
     "dependencies": {
         "@aws-crypto/sha256-js": "^5.2.0",
@@ -56,11 +59,11 @@
     "devDependencies": {
         "@biomejs/biome": "^2.5.7",
         "@types/node": "^26.1.2",
-        "cypress": "^15.20.1",
-        "cypress-real-events": "^1.15.0",
+        "cypress": "^16.1.0",
+        "cypress-real-events": "^1.15.1",
         "typescript": "^7.0.2"
     },
     "allowScripts": {
-        "cypress@15.20.1": true
+        "cypress@16.1.0": true
     }
 }

package/template/.gitattributes

@@ -0,0 +1,12 @@
+# Biome formats every file with LF (formatter.lineEnding in biome.json), so check
+# them out with LF on every platform. Without this, core.autocrlf=true rewrites
+# them to CRLF on checkout and each Biome run leaves the whole repo flagged as
+# modified with an empty diff.
+* text=auto eol=lf
+
+# Binary assets - never convert or diff their bytes
+*.xlsx binary
+*.jasper binary
+*.pdf binary
+*.png binary
+*.jpg binary

package/template/package.json

@@ -1,14 +1,17 @@
 {
     "name": "__PACKAGE_NAME__",
+    "engines": {
+        "node": "^22.0.0 || ^24.0.0 || >=26.0.0"
+    },
     "dependencies": {
         "@globisnv/cypress-core": "^__CORE_VERSION__",
-        "cypress-real-events": "^1.15.0",
+        "cypress-real-events": "^1.15.1",
         "typescript": "^7.0.2"
     },
     "devDependencies": {
         "@biomejs/biome": "^2.5.7",
         "@types/node": "^26.1.2",
-        "cypress": "^15.20.1"
+        "cypress": "^16.0.0"
     },
     "scripts": {
         "lint": "biome check . && node node_modules/@globisnv/cypress-core/scripts/check-unnecessary-waiting.mjs",