@afixt/test-utils 2.3.0 → 2.5.0

package/test/detectFocusTrap.test.js

@@ -0,0 +1,1004 @@
+/**
+ * @file Tests for detectFocusTrap utility
+ * @description Verifies focus trap detection through static DOM analysis
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { detectFocusTrap } from '../src/detectFocusTrap.js';
+
+describe('detectFocusTrap', () => {
+    let container;
+
+    beforeEach(() => {
+        document.body.innerHTML = '';
+    });
+
+    // === Batch 1: Input validation & edge cases ===
+
+    describe('input validation', () => {
+        it('should return not trapped for null input', () => {
+            const result = detectFocusTrap(null);
+            expect(result.isTrapped).toBe(false);
+            expect(result.focusableCount).toBe(0);
+            expect(result.indicators).toEqual([]);
+            expect(result.trapType).toBe('none');
+        });
+
+        it('should return not trapped for undefined input', () => {
+            const result = detectFocusTrap(undefined);
+            expect(result.isTrapped).toBe(false);
+            expect(result.trapType).toBe('none');
+        });
+
+        it('should return not trapped for non-element input', () => {
+            const result = detectFocusTrap('not an element');
+            expect(result.isTrapped).toBe(false);
+            expect(result.trapType).toBe('none');
+        });
+
+        it('should return not trapped for empty container with no focusable elements', () => {
+            container = document.createElement('div');
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(false);
+            expect(result.focusableCount).toBe(0);
+            expect(result.trapType).toBe('none');
+        });
+
+        it('should return correct focusableCount for container with focusable elements', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>One</button><button>Two</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.focusableCount).toBe(2);
+        });
+    });
+
+    describe('return value structure', () => {
+        it('should always return an object with isTrapped, focusableCount, indicators, and trapType', () => {
+            container = document.createElement('div');
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result).toHaveProperty('isTrapped');
+            expect(result).toHaveProperty('focusableCount');
+            expect(result).toHaveProperty('indicators');
+            expect(result).toHaveProperty('trapType');
+            expect(typeof result.isTrapped).toBe('boolean');
+            expect(typeof result.focusableCount).toBe('number');
+            expect(Array.isArray(result.indicators)).toBe(true);
+            expect(typeof result.trapType).toBe('string');
+        });
+
+        it('should not be trapped when there are indicators but no focusable elements', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(false);
+            expect(result.focusableCount).toBe(0);
+            expect(result.indicators.length).toBeGreaterThan(0);
+        });
+    });
+
+    // === Batch 2: Modal dialog patterns ===
+
+    describe('modal dialog detection', () => {
+        it('should detect role="dialog" with aria-modal="true" on container', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button><input type="text">';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.trapType).toBe('modal');
+            expect(result.indicators).toContain('modal-dialog');
+        });
+
+        it('should detect role="alertdialog" with aria-modal="true"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'alertdialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>OK</button><button>Cancel</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.trapType).toBe('modal');
+        });
+
+        it('should not detect dialog without aria-modal="true"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).not.toContain('modal-dialog');
+        });
+
+        it('should detect native <dialog open> element', () => {
+            container = document.createElement('dialog');
+            container.setAttribute('open', '');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.trapType).toBe('modal');
+            expect(result.indicators).toContain('modal-dialog');
+        });
+
+        it('should not detect <dialog> without open attribute', () => {
+            container = document.createElement('dialog');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).not.toContain('modal-dialog');
+        });
+
+        it('should detect modal dialog on ancestor element', () => {
+            const modal = document.createElement('div');
+            modal.setAttribute('role', 'dialog');
+            modal.setAttribute('aria-modal', 'true');
+            container = document.createElement('div');
+            container.innerHTML = '<button>Save</button>';
+            modal.appendChild(container);
+            document.body.appendChild(modal);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.trapType).toBe('modal');
+        });
+    });
+
+    // === Batch 3: Inert siblings ===
+
+    describe('inert siblings detection', () => {
+        it('should detect when all siblings have inert attribute', () => {
+            const wrapper = document.createElement('div');
+            const sibling1 = document.createElement('div');
+            sibling1.setAttribute('inert', '');
+            sibling1.textContent = 'Background content';
+            const sibling2 = document.createElement('div');
+            sibling2.setAttribute('inert', '');
+            sibling2.textContent = 'More background';
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(sibling1);
+            wrapper.appendChild(container);
+            wrapper.appendChild(sibling2);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.trapType).toBe('inert');
+            expect(result.indicators).toContain('inert-siblings');
+        });
+
+        it('should not detect when only some siblings have inert', () => {
+            const wrapper = document.createElement('div');
+            const sibling1 = document.createElement('div');
+            sibling1.setAttribute('inert', '');
+            const sibling2 = document.createElement('div');
+            // No inert attribute
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(sibling1);
+            wrapper.appendChild(container);
+            wrapper.appendChild(sibling2);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).not.toContain('inert-siblings');
+        });
+
+        it('should not detect inert siblings when container has no siblings', () => {
+            const wrapper = document.createElement('div');
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).not.toContain('inert-siblings');
+        });
+    });
+
+    // === Batch 4: Library markers ===
+
+    describe('library marker detection', () => {
+        it('should detect data-focus-trap attribute on container', () => {
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.indicators).toContain('library-markers');
+            expect(result.trapType).toBe('library');
+        });
+
+        it('should detect data-focus-lock attribute on container', () => {
+            container = document.createElement('div');
+            container.setAttribute('data-focus-lock', '');
+            container.innerHTML = '<input type="text">';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('library-markers');
+            expect(result.trapType).toBe('library');
+        });
+
+        it('should detect data-focus-guard attribute on ancestor', () => {
+            const wrapper = document.createElement('div');
+            wrapper.setAttribute('data-focus-guard', '');
+            container = document.createElement('div');
+            container.innerHTML = '<button>OK</button>';
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('library-markers');
+        });
+
+        it('should detect sentinel elements at container boundaries', () => {
+            container = document.createElement('div');
+            const sentinel1 = document.createElement('div');
+            sentinel1.setAttribute('tabindex', '0');
+            const content = document.createElement('div');
+            content.innerHTML = '<button>Action</button>';
+            const sentinel2 = document.createElement('div');
+            sentinel2.setAttribute('tabindex', '0');
+            container.appendChild(sentinel1);
+            container.appendChild(content);
+            container.appendChild(sentinel2);
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('library-markers');
+        });
+
+        it('should not detect sentinel when div has content', () => {
+            container = document.createElement('div');
+            const notSentinel = document.createElement('div');
+            notSentinel.setAttribute('tabindex', '0');
+            notSentinel.textContent = 'I have content';
+            const content = document.createElement('div');
+            content.innerHTML = '<button>Action</button>';
+            container.appendChild(notSentinel);
+            container.appendChild(content);
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).not.toContain('library-markers');
+        });
+
+        it('should detect data-focus-lock-disabled on ancestor', () => {
+            const wrapper = document.createElement('div');
+            wrapper.setAttribute('data-focus-lock-disabled', 'false');
+            container = document.createElement('div');
+            container.innerHTML = '<button>Submit</button>';
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('library-markers');
+        });
+    });
+
+    // === Batch 5: Keyboard & focus event listeners ===
+
+    describe('keyboard listener detection', () => {
+        it('should detect keydown addEventListener on container', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.indicators).toContain('keyboard-listeners');
+            expect(result.trapType).toBe('custom');
+        });
+
+        it('should detect keypress addEventListener on container', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keypress', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('keyboard-listeners');
+        });
+
+        it('should detect inline onkeydown attribute', () => {
+            container = document.createElement('div');
+            container.setAttribute('onkeydown', 'handleKey(event)');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('keyboard-listeners');
+        });
+
+        it('should detect keyboard listener on ancestor', () => {
+            const wrapper = document.createElement('div');
+            wrapper.addEventListener('keydown', () => {});
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('keyboard-listeners');
+        });
+    });
+
+    describe('focus listener detection', () => {
+        it('should detect focusin addEventListener on container', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('focusin', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.indicators).toContain('focus-listeners');
+            expect(result.trapType).toBe('custom');
+        });
+
+        it('should detect focusout addEventListener on container', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('focusout', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('focus-listeners');
+        });
+
+        it('should detect blur addEventListener on container', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('blur', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('focus-listeners');
+        });
+
+        it('should detect inline onfocusin attribute', () => {
+            container = document.createElement('div');
+            container.setAttribute('onfocusin', 'handleFocus(event)');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('focus-listeners');
+        });
+
+        it('should detect focus listener on ancestor', () => {
+            const wrapper = document.createElement('div');
+            wrapper.addEventListener('focusin', () => {});
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('focus-listeners');
+        });
+    });
+
+    // === Batch 6: Combined / priority scenarios ===
+
+    describe('priority and combined scenarios', () => {
+        it('should prioritize modal over library markers', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.trapType).toBe('modal');
+            expect(result.indicators).toContain('modal-dialog');
+            expect(result.indicators).toContain('library-markers');
+        });
+
+        it('should prioritize modal over custom listeners', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.trapType).toBe('modal');
+            expect(result.indicators).toContain('modal-dialog');
+            expect(result.indicators).toContain('keyboard-listeners');
+        });
+
+        it('should prioritize inert over library markers', () => {
+            const wrapper = document.createElement('div');
+            const sibling = document.createElement('div');
+            sibling.setAttribute('inert', '');
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(sibling);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.trapType).toBe('inert');
+            expect(result.indicators).toContain('inert-siblings');
+            expect(result.indicators).toContain('library-markers');
+        });
+
+        it('should prioritize library over custom listeners when no modal/inert', () => {
+            container = document.createElement('div');
+            container.setAttribute('data-focus-lock', '');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.trapType).toBe('library');
+            expect(result.indicators).toContain('library-markers');
+            expect(result.indicators).toContain('keyboard-listeners');
+        });
+
+        it('should report multiple indicators even when trapType follows priority', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            container.addEventListener('focusin', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.trapType).toBe('modal');
+            expect(result.indicators.length).toBe(4);
+            expect(result.indicators).toContain('modal-dialog');
+            expect(result.indicators).toContain('library-markers');
+            expect(result.indicators).toContain('keyboard-listeners');
+            expect(result.indicators).toContain('focus-listeners');
+        });
+
+        it('should return trapType custom when only keyboard listeners present', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.trapType).toBe('custom');
+        });
+
+        it('should return trapType custom when only focus listeners present', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('focusin', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.trapType).toBe('custom');
+        });
+
+        it('should return trapType none for plain container with focusable elements but no trap indicators', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button><input type="text">';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(false);
+            expect(result.trapType).toBe('none');
+            expect(result.focusableCount).toBe(2);
+            expect(result.indicators).toEqual([]);
+        });
+    });
+
+    // === Batch 7: Harmful focus traps — concerns detection ===
+
+    describe('concerns field in return value', () => {
+        it('should include concerns array in return value', () => {
+            container = document.createElement('div');
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result).toHaveProperty('concerns');
+            expect(Array.isArray(result.concerns)).toBe(true);
+        });
+
+        it('should return empty concerns for a properly-formed modal dialog', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<input type="text"><button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toEqual([]);
+        });
+
+        it('should return empty concerns when no trap is detected', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>OK</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toEqual([]);
+        });
+    });
+
+    describe('non-modal trap detection', () => {
+        it('should flag non-modal-trap when custom trap is on a plain div', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            container.addEventListener('focusin', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('non-modal-trap');
+        });
+
+        it('should flag non-modal-trap for library trap without dialog role', () => {
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<a href="#">Link</a>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('non-modal-trap');
+        });
+
+        it('should not flag non-modal-trap for modal dialog', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('non-modal-trap');
+        });
+
+        it('should not flag non-modal-trap for native <dialog open>', () => {
+            container = document.createElement('dialog');
+            container.setAttribute('open', '');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('non-modal-trap');
+        });
+
+        it('should not flag non-modal-trap for inert sibling pattern', () => {
+            const wrapper = document.createElement('div');
+            const sibling = document.createElement('div');
+            sibling.setAttribute('inert', '');
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(sibling);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('non-modal-trap');
+        });
+    });
+
+    describe('single focusable element trap', () => {
+        it('should flag single-focusable when trap has only one focusable element', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.focusableCount).toBe(1);
+            expect(result.concerns).toContain('single-focusable');
+        });
+
+        it('should not flag single-focusable when trap has multiple focusable elements', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<input type="text"><button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.focusableCount).toBe(2);
+            expect(result.concerns).not.toContain('single-focusable');
+        });
+    });
+
+    describe('no escape mechanism', () => {
+        it('should flag no-escape-mechanism for custom trap without close/cancel button', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<input type="text"><input type="text">';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            container.addEventListener('focusin', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('no-escape-mechanism');
+        });
+
+        it('should not flag no-escape-mechanism when a close button exists', () => {
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<input type="text"><button>Close</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('no-escape-mechanism');
+        });
+
+        it('should not flag no-escape-mechanism when a cancel button exists', () => {
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<input type="text"><button>Cancel</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('no-escape-mechanism');
+        });
+
+        it('should not flag no-escape-mechanism for button with aria-label close', () => {
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<input type="text"><button aria-label="Close">X</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('no-escape-mechanism');
+        });
+
+        it('should not flag no-escape-mechanism when Escape keydown handler exists', () => {
+            container = document.createElement('div');
+            container.innerHTML = '<input type="text"><input type="text">';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            container.addEventListener('focusin', () => {});
+            // Simulate having an ancestor with keydown that could handle Escape
+            // The modal pattern inherently implies escape support
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('no-escape-mechanism');
+        });
+    });
+
+    // === Batch 8: aria-hidden siblings creating screen reader traps ===
+
+    describe('aria-hidden siblings detection', () => {
+        it('should detect aria-hidden siblings as a trap indicator', () => {
+            const wrapper = document.createElement('div');
+            const sibling1 = document.createElement('div');
+            sibling1.setAttribute('aria-hidden', 'true');
+            sibling1.textContent = 'Hidden nav';
+            const sibling2 = document.createElement('div');
+            sibling2.setAttribute('aria-hidden', 'true');
+            sibling2.textContent = 'Hidden footer';
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(sibling1);
+            wrapper.appendChild(container);
+            wrapper.appendChild(sibling2);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.indicators).toContain('aria-hidden-siblings');
+        });
+
+        it('should not detect when only some siblings have aria-hidden', () => {
+            const wrapper = document.createElement('div');
+            const sibling1 = document.createElement('div');
+            sibling1.setAttribute('aria-hidden', 'true');
+            const sibling2 = document.createElement('div');
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(sibling1);
+            wrapper.appendChild(container);
+            wrapper.appendChild(sibling2);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).not.toContain('aria-hidden-siblings');
+        });
+
+        it('should flag aria-hidden-no-modal concern when no modal semantics', () => {
+            const wrapper = document.createElement('div');
+            const sibling = document.createElement('div');
+            sibling.setAttribute('aria-hidden', 'true');
+            container = document.createElement('div');
+            container.innerHTML = '<button>Action</button>';
+            wrapper.appendChild(sibling);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('aria-hidden-no-modal');
+        });
+
+        it('should not flag aria-hidden-no-modal when container is a modal dialog', () => {
+            const wrapper = document.createElement('div');
+            const sibling = document.createElement('div');
+            sibling.setAttribute('aria-hidden', 'true');
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button>';
+            wrapper.appendChild(sibling);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('aria-hidden-no-modal');
+        });
+    });
+
+    // === Batch 9: Tabindex manipulation traps ===
+
+    describe('tabindex manipulation detection', () => {
+        it('should detect tabindex="-1" on focusable siblings as a trap indicator', () => {
+            const wrapper = document.createElement('div');
+            const nav = document.createElement('nav');
+            nav.innerHTML =
+                '<a href="/home" tabindex="-1">Home</a><a href="/about" tabindex="-1">About</a>';
+            container = document.createElement('div');
+            container.innerHTML = '<button>Submit</button>';
+            wrapper.appendChild(nav);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.indicators).toContain('tabindex-manipulation');
+        });
+
+        it('should not flag tabindex manipulation when siblings have no defocused elements', () => {
+            const wrapper = document.createElement('div');
+            const nav = document.createElement('nav');
+            nav.innerHTML = '<a href="/home">Home</a><a href="/about">About</a>';
+            container = document.createElement('div');
+            container.innerHTML = '<button>Submit</button>';
+            wrapper.appendChild(nav);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).not.toContain('tabindex-manipulation');
+        });
+
+        it('should flag tabindex-manipulation concern on non-modal trap', () => {
+            const wrapper = document.createElement('div');
+            const aside = document.createElement('aside');
+            aside.innerHTML = '<button tabindex="-1">Disabled nav button</button>';
+            container = document.createElement('div');
+            container.innerHTML = '<input type="text"><button>Go</button>';
+            wrapper.appendChild(aside);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('tabindex-manipulation');
+        });
+
+        it('should not flag tabindex-manipulation concern when container is modal', () => {
+            const wrapper = document.createElement('div');
+            const aside = document.createElement('aside');
+            aside.innerHTML = '<button tabindex="-1">Nav button</button>';
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button>';
+            wrapper.appendChild(aside);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('tabindex-manipulation');
+        });
+
+        it('should detect tabindex="-1" on naturally focusable elements outside container', () => {
+            const wrapper = document.createElement('div');
+            const header = document.createElement('header');
+            header.innerHTML =
+                '<input type="search" tabindex="-1"><button tabindex="-1">Search</button>';
+            container = document.createElement('div');
+            container.innerHTML = '<textarea></textarea><button>Save</button>';
+            wrapper.appendChild(header);
+            wrapper.appendChild(container);
+            document.body.appendChild(wrapper);
+            const result = detectFocusTrap(container);
+            expect(result.indicators).toContain('tabindex-manipulation');
+        });
+    });
+
+    // === Batch 10: Widget-role traps (menus, tooltips, nav, listboxes) ===
+
+    describe('inappropriate widget-role traps', () => {
+        it('should flag inappropriate-trap-role for focus trap on role="menu"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'menu');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML =
+                '<div role="menuitem" tabindex="0">Cut</div><div role="menuitem" tabindex="0">Copy</div>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('inappropriate-trap-role');
+        });
+
+        it('should flag inappropriate-trap-role for focus trap on role="tooltip"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'tooltip');
+            container.innerHTML = '<a href="/help" tabindex="0">Learn more</a>';
+            document.body.appendChild(container);
+            container.addEventListener('focusin', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('inappropriate-trap-role');
+        });
+
+        it('should flag inappropriate-trap-role for focus trap on role="navigation"', () => {
+            container = document.createElement('nav');
+            container.innerHTML = '<a href="/home">Home</a><a href="/about">About</a>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            container.addEventListener('focusin', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('inappropriate-trap-role');
+        });
+
+        it('should flag inappropriate-trap-role for focus trap on role="listbox"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'listbox');
+            container.setAttribute('data-focus-lock', '');
+            container.innerHTML =
+                '<div role="option" tabindex="0">Option 1</div><div role="option" tabindex="0">Option 2</div>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('inappropriate-trap-role');
+        });
+
+        it('should flag inappropriate-trap-role for focus trap on role="tabpanel"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'tabpanel');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<input type="text"><button>Submit</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('inappropriate-trap-role');
+        });
+
+        it('should not flag inappropriate-trap-role for role="dialog"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button><input type="text">';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('inappropriate-trap-role');
+        });
+
+        it('should not flag inappropriate-trap-role for role="alertdialog"', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'alertdialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>OK</button><button>Cancel</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('inappropriate-trap-role');
+        });
+
+        it('should flag inappropriate-trap-role for focus trap on <nav> element', () => {
+            container = document.createElement('nav');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<a href="/">Home</a><a href="/contact">Contact</a>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('inappropriate-trap-role');
+        });
+
+        it('should flag inappropriate-trap-role for focus trap on <aside>', () => {
+            container = document.createElement('aside');
+            container.setAttribute('data-focus-lock', '');
+            container.innerHTML = '<a href="/related">Related article</a><a href="/ad">Sponsor</a>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('inappropriate-trap-role');
+        });
+    });
+
+    // === Batch 11: Nested focus traps ===
+
+    describe('nested focus traps', () => {
+        it('should flag nested-trap when container is inside another focus trap', () => {
+            const outer = document.createElement('div');
+            outer.setAttribute('role', 'dialog');
+            outer.setAttribute('aria-modal', 'true');
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<input type="text"><button>Save</button>';
+            outer.appendChild(container);
+            document.body.appendChild(outer);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('nested-trap');
+        });
+
+        it('should flag nested-trap when inside ancestor with data-focus-lock', () => {
+            const outer = document.createElement('div');
+            outer.setAttribute('data-focus-lock', '');
+            const inner = document.createElement('div');
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<button>Action</button><button>Cancel</button>';
+            inner.appendChild(container);
+            outer.appendChild(inner);
+            document.body.appendChild(outer);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('nested-trap');
+        });
+
+        it('should not flag nested-trap when there is no outer trap', () => {
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button><input type="text">';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('nested-trap');
+        });
+    });
+
+    // === Batch 12: Contenteditable and iframe traps ===
+
+    describe('contenteditable traps', () => {
+        it('should detect trap on wrapper around contenteditable with keyboard listeners', () => {
+            container = document.createElement('div');
+            const editor = document.createElement('div');
+            editor.setAttribute('contenteditable', 'true');
+            editor.textContent = 'Editable area';
+            container.appendChild(editor);
+            container.innerHTML += '<button>Format</button>';
+            document.body.appendChild(container);
+            container.addEventListener('keydown', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('contenteditable-trap');
+        });
+
+        it('should detect trap on container wrapping contenteditable with focus listeners', () => {
+            container = document.createElement('div');
+            const editor = document.createElement('div');
+            editor.setAttribute('contenteditable', 'true');
+            editor.textContent = 'Edit me';
+            container.appendChild(editor);
+            const toolbar = document.createElement('div');
+            toolbar.innerHTML = '<button>Bold</button><button>Italic</button>';
+            container.appendChild(toolbar);
+            document.body.appendChild(container);
+            container.addEventListener('focusin', () => {});
+            container.addEventListener('keydown', () => {});
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('contenteditable-trap');
+        });
+
+        it('should not flag contenteditable-trap when no trap indicators', () => {
+            container = document.createElement('div');
+            container.setAttribute('contenteditable', 'true');
+            container.setAttribute('tabindex', '0');
+            container.textContent = 'Editable area';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.isTrapped).toBe(false);
+            expect(result.concerns).not.toContain('contenteditable-trap');
+        });
+    });
+
+    // === Batch 13: Full-page and body-level traps ===
+
+    describe('full page traps', () => {
+        it('should flag full-page-trap when container is the body element', () => {
+            document.body.innerHTML = '<button>Action</button>';
+            document.body.setAttribute('data-focus-trap', 'active');
+            const result = detectFocusTrap(document.body);
+            expect(result.isTrapped).toBe(true);
+            expect(result.concerns).toContain('full-page-trap');
+            document.body.removeAttribute('data-focus-trap');
+        });
+
+        it('should flag full-page-trap when container is direct child of body with no siblings', () => {
+            document.body.innerHTML = '';
+            container = document.createElement('div');
+            container.setAttribute('data-focus-trap', 'active');
+            container.innerHTML = '<button>Action</button>';
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).toContain('full-page-trap');
+        });
+
+        it('should not flag full-page-trap for properly scoped modal', () => {
+            document.body.innerHTML = '';
+            const main = document.createElement('main');
+            main.innerHTML = '<p>Page content</p>';
+            container = document.createElement('div');
+            container.setAttribute('role', 'dialog');
+            container.setAttribute('aria-modal', 'true');
+            container.innerHTML = '<button>Close</button><input type="text">';
+            document.body.appendChild(main);
+            document.body.appendChild(container);
+            const result = detectFocusTrap(container);
+            expect(result.concerns).not.toContain('full-page-trap');
+        });
+    });
+});