fix(modal): focus the dialog wrapper on present so screen readers can enter the modal

core/src/components/modal/gestures/sheet.ts

@@ -298,7 +298,16 @@ export const createSheetGesture = (
     return true;
   };
 
+  /**
+   * In Firefox, pressing over a text caret in the focusable wrapper can
+   * start a native drag that swallows the gesture's pointer events.
+   * Cancel native drag while the gesture is active.
+   */
+  const preventNativeDragStart = (ev: DragEvent) => ev.preventDefault();
+
   const onStart = (detail: GestureDetail) => {
+    baseEl.addEventListener('dragstart', preventNativeDragStart);
+
     /**
      * If canDismiss is anything other than `true`
      * then users should be able to swipe down
@@ -443,6 +452,8 @@ export const createSheetGesture = (
   };
 
   const onEnd = (detail: GestureDetail) => {
+    baseEl.removeEventListener('dragstart', preventNativeDragStart);
+
     const snapBreakpoint = calculateSnapBreakpoint(detail.deltaY);
 
     const eventDetail: ModalDragEventDetail = {

core/src/components/modal/gestures/swipe-to-close.ts

@@ -113,9 +113,18 @@ export const createSwipeToCloseGesture = (
     return false;
   };
 
+  /**
+   * In Firefox, pressing over a text caret in the focusable wrapper can
+   * start a native drag that swallows the gesture's pointer events.
+   * Cancel native drag while the gesture is active.
+   */
+  const preventNativeDragStart = (ev: DragEvent) => ev.preventDefault();
+
   const onStart = (detail: GestureDetail) => {
     const { deltaY } = detail;
 
+    el.addEventListener('dragstart', preventNativeDragStart);
+
     /**
      * Get the initial scrollY value so
      * that we can correctly reset the scrollY
@@ -237,6 +246,8 @@ export const createSwipeToCloseGesture = (
   };
 
   const onEnd = (detail: GestureDetail) => {
+    el.removeEventListener('dragstart', preventNativeDragStart);
+
     const velocity = detail.velocityY;
     const step = detail.deltaY / height;
 

core/src/components/modal/modal.scss

@@ -84,6 +84,14 @@ ion-backdrop {
   z-index: 10;
 }
 
+/**
+ * The wrapper receives programmatic focus for screen readers but should not
+ * show a visible focus ring, which is meant only for keyboard navigation.
+ */
+.modal-wrapper {
+  outline: none;
+}
+
 .modal-shadow {
   position: absolute;
 

core/src/components/modal/modal.tsx

@@ -1644,10 +1644,16 @@ export class Modal implements ComponentInterface, OverlayInterface {
             same element. They must also be set inside the
             shadow DOM otherwise ion-button will not be highlighted
             when using VoiceOver: https://bugs.webkit.org/show_bug.cgi?id=247134
+
+            tabIndex={-1} is required so present() can move focus to this
+            element (which carries the dialog role) instead of the role-less
+            host. role="dialog" alone does not make an element focusable, so
+            without the tabindex focus() would be a no-op.
           */
           role="dialog"
           {...inheritedAttributes}
           aria-modal="true"
+          tabIndex={-1}
           class="modal-wrapper ion-overlay-wrapper"
           part="content"
           ref={(el) => (this.wrapperEl = el)}

core/src/components/modal/test/a11y/modal.e2e.ts

@@ -19,5 +19,22 @@ configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, config }) =>
       const results = await new AxeBuilder({ page }).analyze();
       expect(results.violations).toEqual([]);
     });
+
+    // The focused wrapper must not show a focus ring when opened via keyboard.
+    test('should not render a focus ring on the wrapper when presented via keyboard', async ({ page }) => {
+      await page.goto(`/src/components/modal/test/a11y`, config);
+
+      const ionModalDidPresent = await page.spyOnEvent('ionModalDidPresent');
+      const button = page.locator('#open-modal');
+      const wrapper = page.locator('ion-modal .modal-wrapper');
+
+      // Open with the keyboard so :focus-visible applies to the wrapper.
+      await button.focus();
+      await page.keyboard.press('Enter');
+      await ionModalDidPresent.next();
+
+      await expect(wrapper).toBeFocused();
+      await expect(wrapper).toHaveCSS('outline-style', 'none');
+    });
   });
 });

core/src/components/modal/test/card/modal-card.e2e.ts

@@ -150,5 +150,41 @@ configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, screenshot, c
       expect(ionDragEnd.length).toBe(1);
       expect(Object.keys(dragEndEvent.detail).length).toBe(4);
     });
+
+    // Native drag can interfere with the swipe gesture when initiated over
+    // text in the focusable wrapper. Suppress it during the gesture only.
+    test('should cancel native drag and drop only while the gesture is active', async ({ page }) => {
+      await page.goto('/src/components/modal/test/card', config);
+
+      const ionModalDidPresent = await page.spyOnEvent('ionModalDidPresent');
+
+      await page.click('#drag-events');
+      await ionModalDidPresent.next();
+
+      const ionDragStart = await page.spyOnEvent('ionDragStart');
+      const ionDragEnd = await page.spyOnEvent('ionDragEnd');
+
+      const dispatchNativeDragStart = () => {
+        return page.evaluate(() => {
+          const content = document.querySelector('.modal-card ion-content')!;
+          const ev = new DragEvent('dragstart', { bubbles: true, cancelable: true, composed: true });
+          content.dispatchEvent(ev);
+          return ev.defaultPrevented;
+        });
+      };
+
+      const header = page.locator('.modal-card ion-header');
+
+      // Hold the drag mid-gesture without releasing
+      await dragElementBy(header, page, 0, 50, undefined, undefined, false);
+      await ionDragStart.next();
+
+      expect(await dispatchNativeDragStart()).toBe(true);
+
+      await page.mouse.up();
+      await ionDragEnd.next();
+
+      expect(await dispatchNativeDragStart()).toBe(false);
+    });
   });
 });

core/src/components/modal/test/sheet/modal.e2e.ts

@@ -398,6 +398,42 @@ configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, config }) =>
       expect(ionDragEnd.length).toBe(1);
       expect(Object.keys(dragEndEvent.detail).length).toBe(5);
     });
+
+    // Native drag can interfere with the swipe gesture when initiated over
+    // text in the focusable wrapper. Suppress it during the gesture only.
+    test('should cancel native drag and drop only while the gesture is active', async ({ page }) => {
+      await page.goto('/src/components/modal/test/sheet', config);
+
+      const ionModalDidPresent = await page.spyOnEvent('ionModalDidPresent');
+
+      await page.click('#drag-events');
+      await ionModalDidPresent.next();
+
+      const ionDragStart = await page.spyOnEvent('ionDragStart');
+      const ionDragEnd = await page.spyOnEvent('ionDragEnd');
+
+      const dispatchNativeDragStart = () => {
+        return page.evaluate(() => {
+          const content = document.querySelector('.modal-sheet ion-content')!;
+          const ev = new DragEvent('dragstart', { bubbles: true, cancelable: true, composed: true });
+          content.dispatchEvent(ev);
+          return ev.defaultPrevented;
+        });
+      };
+
+      const header = page.locator('.modal-sheet ion-header');
+
+      // Hold the drag mid-gesture without releasing
+      await dragElementBy(header, page, 0, 50, undefined, undefined, false);
+      await ionDragStart.next();
+
+      expect(await dispatchNativeDragStart()).toBe(true);
+
+      await page.mouse.up();
+      await ionDragEnd.next();
+
+      expect(await dispatchNativeDragStart()).toBe(false);
+    });
   });
 
   test.describe(title('sheet modal: late breakpoints binding'), () => {

core/src/utils/overlays.ts

@@ -593,7 +593,28 @@ export const present = async <OverlayPresentOptions>(
    * to the overlay container.
    */
   if (overlay.keyboardClose && (document.activeElement === null || !overlay.el.contains(document.activeElement))) {
-    overlay.el.focus();
+    /**
+     * Some overlays (e.g. modal) put the dialog role and label on the
+     * `.ion-overlay-wrapper` rather than the host. Screen readers need
+     * focus on the element with role="dialog" to properly announce and
+     * navigate the dialog. The `[tabindex]` qualifier ensures we only
+     * target such a wrapper when it is actually focusable; otherwise
+     * (e.g. picker-legacy, whose role="dialog" wrapper has no tabindex)
+     * `focus()` would be a no-op, so we fall back to the host.
+     */
+    const overlayWrapper = getElementRoot(overlay.el).querySelector<HTMLElement>('[role="dialog"][tabindex]');
+    const focusTarget = overlayWrapper ?? overlay.el;
+    /**
+     * `preventScroll` keeps this a pure focus move so the viewport does not
+     * jump when the wrapper is partially off-screen (e.g. a sheet modal).
+     * Guard the options call so an older engine that mishandles it can never
+     * reject present(); we fall back to a plain focus() in that case.
+     */
+    try {
+      focusTarget.focus({ preventScroll: true });
+    } catch {
+      focusTarget.focus();
+    }
   }
 
   /**

core/src/utils/test/overlays/overlays.e2e.ts

@@ -421,5 +421,87 @@ configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, config }) =>
       // verify focus is in correct location
       await expect(input).toBeFocused();
     });
+
+    // Focus the role="dialog" wrapper on present so screen readers can enter.
+    test('should focus the modal wrapper on present', async ({ page }, testInfo) => {
+      testInfo.annotations.push({
+        type: 'issue',
+        description: 'FW-7611',
+      });
+      await page.setContent(
+        `
+        <ion-modal>
+          <ion-content>Modal Content</ion-content>
+        </ion-modal>
+      `,
+        config
+      );
+
+      const ionModalDidPresent = await page.spyOnEvent('ionModalDidPresent');
+      const modal = page.locator('ion-modal');
+      const wrapper = page.locator('ion-modal .modal-wrapper');
+
+      await modal.evaluate((el: HTMLIonModalElement) => el.present());
+      await ionModalDidPresent.next();
+
+      await expect(wrapper).toHaveAttribute('role', 'dialog');
+      await expect(wrapper).toBeFocused();
+    });
+
+    test('should focus the sheet modal wrapper on present', async ({ page }, testInfo) => {
+      testInfo.annotations.push({
+        type: 'issue',
+        description: 'FW-7611',
+      });
+      await page.setContent(
+        `
+        <ion-modal initial-breakpoint="0.5" breakpoints="[0, 0.5, 1]">
+          <ion-content>Sheet Modal Content</ion-content>
+        </ion-modal>
+      `,
+        config
+      );
+
+      const ionModalDidPresent = await page.spyOnEvent('ionModalDidPresent');
+      const modal = page.locator('ion-modal');
+      const wrapper = page.locator('ion-modal .modal-wrapper');
+
+      await modal.evaluate((el: HTMLIonModalElement) => el.present());
+      await ionModalDidPresent.next();
+
+      await expect(wrapper).toHaveAttribute('role', 'dialog');
+      await expect(wrapper).toBeFocused();
+    });
+
+    test('should focus the card modal wrapper on present', async ({ page }, testInfo) => {
+      testInfo.annotations.push({
+        type: 'issue',
+        description: 'FW-7611',
+      });
+      await page.setContent(
+        `
+        <div class="ion-page">
+          <ion-content>Root Content</ion-content>
+        </div>
+        <ion-modal>
+          <ion-content>Card Modal Content</ion-content>
+        </ion-modal>
+      `,
+        config
+      );
+
+      const ionModalDidPresent = await page.spyOnEvent('ionModalDidPresent');
+      const modal = page.locator('ion-modal');
+      const wrapper = page.locator('ion-modal .modal-wrapper');
+
+      await modal.evaluate((el: HTMLIonModalElement) => {
+        el.presentingElement = document.querySelector<HTMLElement>('.ion-page')!;
+        return el.present();
+      });
+      await ionModalDidPresent.next();
+
+      await expect(wrapper).toHaveAttribute('role', 'dialog');
+      await expect(wrapper).toBeFocused();
+    });
   });
 });