Overlay: Should focus next focusable element if target is deleted (T1248343) (DevExpress#29342)

Co-authored-by: Ruslan Farkhutdinov <[email protected]>

Author: r-farkhutdinov

packages/devextreme/js/__internal/ui/overlay/m_overlay.ts

@@ -783,47 +783,47 @@ class Overlay<
   _findTabbableBounds(): { first: dxElementWrapper | null; last: dxElementWrapper | null } {
     const $elements = this._$wrapper.find('*');
     const elementsCount = $elements.length - 1;
-    const result = { first: null, last: null };
 
-    for (let i = 0; i <= elementsCount; i++) {
+    let first = null;
+    let last = null;
+
+    for (let i = 0; i <= elementsCount; i += 1) {
       // @ts-expect-error ts-error
-      if (!result.first && $elements.eq(i).is(tabbable)) {
+      if (!first && $elements.eq(i).is(tabbable)) {
         // @ts-expect-error ts-error
-        result.first = $elements.eq(i);
+        first = $elements.eq(i);
       }
       // @ts-expect-error ts-error
-      if (!result.last && $elements.eq(elementsCount - i).is(tabbable)) {
+      if (!last && $elements.eq(elementsCount - i).is(tabbable)) {
         // @ts-expect-error ts-error
-        result.last = $elements.eq(elementsCount - i);
+        last = $elements.eq(elementsCount - i);
       }
 
-      if (result.first && result.last) {
+      if (first && last) {
         break;
       }
     }
 
-    return result;
+    return { first, last };
   }
 
-  _tabKeyHandler(e): void {
+  _tabKeyHandler(e: KeyboardEvent): void {
     if (normalizeKeyName(e) !== TAB_KEY || !this._isTopOverlay()) {
       return;
     }
 
-    const tabbableElements = this._findTabbableBounds();
+    const wrapper = this._$wrapper.get(0) as HTMLElement;
+    const activeElement = domAdapter.getActiveElement(wrapper);
 
-    const $firstTabbable = tabbableElements.first;
-    const $lastTabbable = tabbableElements.last;
-    // @ts-expect-error ts-error
-    const isTabOnLast = !e.shiftKey && e.target === $lastTabbable.get(0);
-    // @ts-expect-error ts-error
-    const isShiftTabOnFirst = e.shiftKey && e.target === $firstTabbable.get(0);
-    // @ts-expect-error ts-error
-    const isEmptyTabList = tabbableElements.length === 0;
-    const isOutsideTarget = !domUtils.contains(this._$wrapper.get(0), e.target);
+    const { first: $firstTabbable, last: $lastTabbable } = this._findTabbableBounds();
+
+    const isTabOnLast = !e.shiftKey && activeElement === $lastTabbable?.get(0);
+    const isShiftTabOnFirst = e.shiftKey && activeElement === $firstTabbable?.get(0);
+    const isOutsideTarget = !domUtils.contains(wrapper, activeElement);
+
+    const shouldPreventDefault = isTabOnLast || isShiftTabOnFirst || isOutsideTarget;
 
-    if (isTabOnLast || isShiftTabOnFirst
-            || isEmptyTabList || isOutsideTarget) {
+    if (shouldPreventDefault) {
       e.preventDefault();
 
       const $focusElement = e.shiftKey ? $lastTabbable : $firstTabbable;

packages/devextreme/testing/tests/DevExpress.ui.widgets/overlay.tests.js

@@ -3446,6 +3446,57 @@ testModule('focus policy', {
 
         assert.strictEqual(contentFocusHandler.callCount, 1, 'focus has been triggered once from keyboardMock');
     });
+
+    test('tab behavior should remain default when event.target is removed from DOM (T1248343)', function(assert) {
+        const overlay = new Overlay($('<div>').appendTo('#qunit-fixture'), {
+            visible: true,
+            shading: true,
+            contentTemplate: $('<div>')
+                .append('<input class="templateField">')
+                .append('<input class="anotherField">')
+                .append('<input class="thirdField">'),
+        });
+
+        const $content = $(overlay.$content());
+        const $templateField = $content.find('.templateField');
+        const $anotherField = $content.find('.anotherField');
+
+        $templateField.trigger('focus');
+
+        assert.strictEqual(getActiveElement(), $templateField.get(0), 'templatedField is focused');
+
+        $templateField.remove();
+
+        $anotherField.trigger('focus');
+
+        const tabEvent = $.Event('keydown', { key: 'Tab', shiftKey: false, target: $templateField.get(0) });
+
+        $(document).trigger(tabEvent);
+        assert.strictEqual(tabEvent.isDefaultPrevented(), false, 'event is not prevented');
+    });
+
+    test('tab event is prevented when removed target was outside overlay', function(assert) {
+        const overlay = new Overlay($('<div>').appendTo('#qunit-fixture'), {
+            visible: true,
+            shading: true,
+            contentTemplate: $('<div>')
+                .append('<input class="templateField">')
+        });
+
+        const $content = $(overlay.$content());
+        const $templateField = $content.find('.templateField');
+        const $outerField = $('<input class="outerField">').appendTo('#qunit-fixture');
+        $outerField.trigger('focus');
+        assert.strictEqual(getActiveElement(), $outerField.get(0), 'outerField is focused');
+
+        $outerField.remove();
+
+        const tabEventOutside = $.Event('keydown', { key: 'Tab', shiftKey: false, target: $outerField.get(0) });
+        $(document).trigger(tabEventOutside);
+
+        assert.strictEqual(tabEventOutside.isDefaultPrevented(), true, 'event is prevented when target removed outside overlay');
+        assert.strictEqual(getActiveElement(), $templateField.get(0), 'focus is returned to Popup');
+    });
 });
 
 testModule('preventScrollEvents', () => {