@ionic/core 8.8.20-dev.11787158518.168a2fea → 8.8.20-dev.11788449221.155f9f1e

package/dist/collection/components/header/header.js

@@ -4,35 +4,69 @@
 import { Host, h, writeTask } from "@stencil/core";
 import { findIonContent, getScrollElement, printIonContentErrorMsg } from "../../utils/content/index";
 import { inheritAriaAttributes } from "../../utils/helpers";
+import { printIonWarning } from "../../utils/logging/index";
+import { createScrollHideController } from "../../utils/scroll-hide-controller";
 import { hostContext } from "../../utils/theme";
-import { getIonMode } from "../../global/ionic-global";
+import { config } from "../../global/config";
+import { getIonTheme } from "../../global/ionic-global";
 import { cloneElement, createHeaderIndex, handleContentScroll, handleHeaderFade, handleToolbarIntersection, setHeaderActive, setToolbarBackgroundOpacity, getRoleType, } from "./header.utils";
 /**
- * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
  */
 export class Header {
-    scrollEl;
-    contentScrollCallback;
-    intersectionObserver;
-    collapsibleMainHeader;
-    inheritedAttributes = {};
-    el;
-    /**
-     * Describes the scroll effect that will be applied to the header.
-     * Only applies in iOS mode.
-     *
-     * Typically used for [Collapsible Large Titles](https://ionicframework.com/docs/api/title#collapsible-large-titles)
-     */
-    collapse;
-    /**
-     * If `true`, the header will be translucent.
-     * Only applies when the mode is `"ios"` and the device supports
-     * [`backdrop-filter`](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter#Browser_compatibility).
-     *
-     * Note: In order to scroll content behind the header, the `fullscreen`
-     * attribute needs to be set on the content.
-     */
-    translucent = false;
+    constructor() {
+        this.inheritedAttributes = {};
+        this.scrollHideCtrlPromise = null;
+        this.hasWarnedCollapse = false;
+        this.fadeCondenseSetupId = 0;
+        /**
+         * If `true`, the header will have a line at the bottom.
+         * TODO(ROU-10855): add support for this prop on ios/md themes
+         */
+        this.divider = false;
+        /**
+         * If `true`, the header will be translucent.
+         * Only applies when the theme is `"ios"` or `"ionic"` and the device supports
+         * [`backdrop-filter`](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter#Browser_compatibility).
+         *
+         * Note: In order to scroll content behind the header, the `fullscreen`
+         * attribute needs to be set on the content.
+         */
+        this.translucent = false;
+        this.setupScrollEffectHide = async (contentEl) => {
+            const setupPromise = createScrollHideController(contentEl, {
+                el: this.el,
+                cssVar: '--internal-header-hide-height',
+                hiddenClass: 'header-scroll-hidden',
+                contentPartnerClass: 'content-header-hide-scroll-partner',
+                contentHiddenClass: 'content-header-hide-scroll-hidden',
+            });
+            this.scrollHideCtrlPromise = setupPromise;
+            const controller = await setupPromise;
+            if (this.scrollHideCtrlPromise === setupPromise) {
+                this.scrollHideCtrlPromise = null;
+                controller.init();
+                this.scrollHideCtrl = controller;
+            }
+        };
+        this.setupFadeHeader = async (contentEl, condenseHeader) => {
+            const setupId = ++this.fadeCondenseSetupId;
+            const scrollEl = await getScrollElement(contentEl);
+            if (this.fadeCondenseSetupId !== setupId) {
+                return;
+            }
+            this.scrollEl = scrollEl;
+            /**
+             * Handle fading of toolbars on scroll
+             */
+            this.contentScrollCallback = () => {
+                handleHeaderFade(this.scrollEl, this.el, condenseHeader);
+            };
+            scrollEl.addEventListener('scroll', this.contentScrollCallback);
+            handleHeaderFade(this.scrollEl, this.el, condenseHeader);
+        };
+    }
     componentWillLoad() {
         this.inheritedAttributes = inheritAriaAttributes(this.el);
     }
@@ -46,48 +80,63 @@ export class Header {
         this.destroyCollapsibleHeader();
     }
     async checkCollapsibleHeader() {
-        const mode = getIonMode(this);
-        if (mode !== 'ios') {
+        const { scrollEffect, collapse } = this;
+        if (collapse !== undefined && scrollEffect === undefined && !this.hasWarnedCollapse) {
+            this.hasWarnedCollapse = true;
+            printIonWarning(`[ion-header] - The \`collapse\` property is deprecated. Use \`scrollEffect\` instead.\nExample: <ion-header scroll-effect="${collapse}">`, this.el);
+        }
+        const effect = scrollEffect !== null && scrollEffect !== void 0 ? scrollEffect : collapse;
+        // Skip teardown/rebuild if the effect hasn't changed.
+        // This prevents re-renders from destroying the scroll controller
+        // and resetting isHidden.
+        if (effect === this.activeEffect) {
             return;
         }
-        const { collapse } = this;
-        const hasCondense = collapse === 'condense';
-        const hasFade = collapse === 'fade';
+        const hasHide = effect === 'hide';
+        const hasCondense = effect === 'condense';
+        const hasFade = effect === 'fade';
         this.destroyCollapsibleHeader();
-        if (hasCondense) {
-            const pageEl = this.el.closest('ion-app,ion-page,.ion-page,page-inner');
-            const contentEl = pageEl ? findIonContent(pageEl) : null;
+        const appRootSelector = config.get('appRootSelector', 'ion-app');
+        const pageEl = this.el.closest(`${appRootSelector}, ion-page, .ion-page, page-inner`);
+        const contentEl = pageEl ? findIonContent(pageEl) : null;
+        if (hasHide && contentEl) {
+            this.activeEffect = effect;
+            await this.setupScrollEffectHide(contentEl);
+            return;
+        }
+        // condense/fade via the deprecated `collapse` prop are iOS-only.
+        // condense/fade via the new `scrollEffect` prop work in all themes.
+        const isModeRestricted = scrollEffect === undefined && getIonTheme(this) !== 'ios';
+        if (hasCondense && !isModeRestricted) {
             // Cloned elements are always needed in iOS transition
             writeTask(() => {
                 const title = cloneElement('ion-title');
                 title.size = 'large';
                 cloneElement('ion-back-button');
             });
-            await this.setupCondenseHeader(contentEl, pageEl);
+            const didSetup = await this.setupCondenseHeader(contentEl, pageEl);
+            if (didSetup) {
+                this.activeEffect = effect;
+            }
         }
-        else if (hasFade) {
-            const pageEl = this.el.closest('ion-app,ion-page,.ion-page,page-inner');
-            const contentEl = pageEl ? findIonContent(pageEl) : null;
+        else if (hasFade && !isModeRestricted) {
             if (!contentEl) {
                 printIonContentErrorMsg(this.el);
                 return;
             }
-            const condenseHeader = contentEl.querySelector('ion-header[collapse="condense"]');
+            const condenseHeader = contentEl.querySelector('ion-header[collapse="condense"],ion-header[scroll-effect="condense"]');
+            this.activeEffect = effect;
             await this.setupFadeHeader(contentEl, condenseHeader);
         }
     }
-    setupFadeHeader = async (contentEl, condenseHeader) => {
-        const scrollEl = (this.scrollEl = await getScrollElement(contentEl));
-        /**
-         * Handle fading of toolbars on scroll
-         */
-        this.contentScrollCallback = () => {
-            handleHeaderFade(this.scrollEl, this.el, condenseHeader);
-        };
-        scrollEl.addEventListener('scroll', this.contentScrollCallback);
-        handleHeaderFade(this.scrollEl, this.el, condenseHeader);
-    };
     destroyCollapsibleHeader() {
+        this.activeEffect = undefined;
+        this.fadeCondenseSetupId++;
+        this.scrollHideCtrlPromise = null;
+        if (this.scrollHideCtrl) {
+            this.scrollHideCtrl.destroy();
+            this.scrollHideCtrl = undefined;
+        }
         if (this.intersectionObserver) {
             this.intersectionObserver.disconnect();
             this.intersectionObserver = undefined;
@@ -104,21 +153,40 @@ export class Header {
     async setupCondenseHeader(contentEl, pageEl) {
         if (!contentEl || !pageEl) {
             printIonContentErrorMsg(this.el);
-            return;
+            return false;
         }
         if (typeof IntersectionObserver === 'undefined') {
-            return;
+            return false;
+        }
+        const setupId = ++this.fadeCondenseSetupId;
+        const scrollEl = await getScrollElement(contentEl);
+        if (this.fadeCondenseSetupId !== setupId) {
+            return false;
+        }
+        this.scrollEl = scrollEl;
+        /**
+         * The condense effect requires an ion-title with size="large"
+         * in the condense header. Without it, there is nothing to
+         * collapse into the main header toolbar.
+         */
+        const hasLargeTitle = this.el.querySelector('ion-title[size="large"]') !== null;
+        if (!hasLargeTitle) {
+            printIonWarning('[ion-header] - The condense scroll effect requires an <ion-title size="large"> in the condense header.', this.el);
+            return false;
         }
-        this.scrollEl = await getScrollElement(contentEl);
         const headers = pageEl.querySelectorAll('ion-header');
-        this.collapsibleMainHeader = Array.from(headers).find((header) => header.collapse !== 'condense');
+        this.collapsibleMainHeader = Array.from(headers).find((header) => {
+            var _a;
+            const effect = (_a = header.scrollEffect) !== null && _a !== void 0 ? _a : header.collapse;
+            return effect !== 'condense';
+        });
         if (!this.collapsibleMainHeader) {
-            return;
+            return false;
         }
         const mainHeaderIndex = createHeaderIndex(this.collapsibleMainHeader);
         const scrollHeaderIndex = createHeaderIndex(this.el);
         if (!mainHeaderIndex || !scrollHeaderIndex) {
-            return;
+            return false;
         }
         setHeaderActive(mainHeaderIndex, false);
         setToolbarBackgroundOpacity(mainHeaderIndex.el, 0);
@@ -150,38 +218,79 @@ export class Header {
                 this.collapsibleMainHeader.classList.add('header-collapse-main');
             }
         });
+        return true;
     }
     render() {
-        const { translucent, inheritedAttributes } = this;
-        const mode = getIonMode(this);
-        const collapse = this.collapse || 'none';
-        const isCondensed = collapse === 'condense';
+        const { translucent, inheritedAttributes, divider, scrollEffect, collapse } = this;
+        const theme = getIonTheme(this);
+        const effect = scrollEffect !== null && scrollEffect !== void 0 ? scrollEffect : collapse;
+        // condense/fade via the deprecated `collapse` prop are iOS-only.
+        const isModeRestricted = scrollEffect === undefined && theme !== 'ios';
+        const hasHide = effect === 'hide';
+        const hasCondense = effect === 'condense' && !isModeRestricted && this.el.querySelector('ion-title[size="large"]') !== null;
+        const hasFade = effect === 'fade' && !isModeRestricted;
+        // The condense header should be hidden when
+        // - deprecated collapse prop is used on non-iOS (mode restricted), or
+        // - scrollEffect="condense" is set but no ion-title[size="large"] is present
+        const isHiddenCondense = effect === 'condense' && !hasCondense;
         // banner role must be at top level, so remove role if inside a menu
-        const roleType = getRoleType(hostContext('ion-menu', this.el), isCondensed, mode);
-        return (h(Host, { key: '863c4568cd7b8c0ec55109f193bbbaed68a1346e', role: roleType, class: {
-                [mode]: true,
+        const roleType = isHiddenCondense ? 'none' : getRoleType(hostContext('ion-menu', this.el));
+        return (h(Host, Object.assign({ key: '09f60ca014bb7b3a85d3c0a94e7989d5dbc43f46', role: roleType, class: {
+                [theme]: true,
                 // Used internally for styling
-                [`header-${mode}`]: true,
+                [`header-${theme}`]: true,
                 [`header-translucent`]: this.translucent,
-                [`header-collapse-${collapse}`]: true,
-                [`header-translucent-${mode}`]: this.translucent,
-            }, ...inheritedAttributes }, mode === 'ios' && translucent && h("div", { key: '25c3bdce328b0b35607d154c8b8374679313d881', class: "header-background" }), h("slot", { key: 'b44fab0a9be7920b9650da26117c783e751e1702' })));
+                ['header-collapse-condense']: hasCondense,
+                ['header-collapse-condense-hidden']: isHiddenCondense,
+                ['header-collapse-fade']: hasFade,
+                [`header-translucent-${theme}`]: this.translucent,
+                ['header-divider']: divider,
+                'header-scroll-effect-hide': hasHide,
+            } }, inheritedAttributes), theme !== 'md' && translucent && h("div", { key: 'fd5ff245ae0166e5e1d50936cacc98c90625db48', class: "header-background" }), h("slot", { key: '1baa31af87b9eb6406a21073ec65afa191dfbb3d' })));
     }
     static get is() { return "ion-header"; }
     static get originalStyleUrls() {
         return {
             "ios": ["header.ios.scss"],
-            "md": ["header.md.scss"]
+            "md": ["header.md.scss"],
+            "ionic": ["header.ionic.scss"]
         };
     }
     static get styleUrls() {
         return {
             "ios": ["header.ios.css"],
-            "md": ["header.md.css"]
+            "md": ["header.md.css"],
+            "ionic": ["header.ionic.css"]
         };
     }
     static get properties() {
         return {
+            "scrollEffect": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "HeaderScrollEffect",
+                    "resolved": "\"condense\" | \"fade\" | \"hide\" | undefined",
+                    "references": {
+                        "HeaderScrollEffect": {
+                            "location": "import",
+                            "path": "./header-interface",
+                            "id": "src/components/header/header-interface.ts::HeaderScrollEffect",
+                            "referenceLocation": "HeaderScrollEffect"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Describes the scroll effect that will be applied to the header.\n`\"hide\"` slides the header out of view when scrolling down and back in\nwhen scrolling up.\n`\"condense\"` collapses the large title into the main toolbar on scroll.\n`\"fade\"` fades the toolbar background on scroll."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "scroll-effect"
+            },
             "collapse": {
                 "type": "string",
                 "mutable": false,
@@ -193,14 +302,37 @@ export class Header {
                 "required": false,
                 "optional": true,
                 "docs": {
-                    "tags": [],
-                    "text": "Describes the scroll effect that will be applied to the header.\nOnly applies in iOS mode.\n\nTypically used for [Collapsible Large Titles](https://ionicframework.com/docs/api/title#collapsible-large-titles)"
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `scrollEffect` instead."
+                        }],
+                    "text": "Describes the scroll effect that will be applied to the header.\nOnly applies when the theme is `\"ios\"`.\n\nTypically used for [Collapsible Large Titles](https://ionicframework.com/docs/api/title#collapsible-large-titles)"
                 },
                 "getter": false,
                 "setter": false,
                 "reflect": false,
                 "attribute": "collapse"
             },
+            "divider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "If `true`, the header will have a line at the bottom.\nTODO(ROU-10855): add support for this prop on ios/md themes"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "divider",
+                "defaultValue": "false"
+            },
             "translucent": {
                 "type": "boolean",
                 "mutable": false,
@@ -213,7 +345,7 @@ export class Header {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "If `true`, the header will be translucent.\nOnly applies when the mode is `\"ios\"` and the device supports\n[`backdrop-filter`](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter#Browser_compatibility).\n\nNote: In order to scroll content behind the header, the `fullscreen`\nattribute needs to be set on the content."
+                    "text": "If `true`, the header will be translucent.\nOnly applies when the theme is `\"ios\"` or `\"ionic\"` and the device supports\n[`backdrop-filter`](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter#Browser_compatibility).\n\nNote: In order to scroll content behind the header, the `fullscreen`\nattribute needs to be set on the content."
                 },
                 "getter": false,
                 "setter": false,

package/dist/collection/components/header/header.md.css

@@ -1,3 +1,173 @@
+ion-header {
+  display: block;
+  position: relative;
+  order: -1;
+  width: 100%;
+}
+
+ion-header ion-toolbar:first-of-type {
+  padding-top: var(--ion-safe-area-top, 0);
+}
+
+.header-collapse-fade ion-toolbar {
+  --opacity-scale: inherit;
+}
+
+/**
+ * Override styles applied during the page transition to prevent
+ * header flickering.
+ */
+.header-collapse-fade.header-transitioning ion-toolbar {
+  --background: transparent;
+  --border-style: none;
+}
+
+.header-collapse-condense {
+  z-index: 9;
+}
+
+.header-collapse-condense ion-toolbar {
+  position: sticky;
+  top: 0;
+}
+
+.header-collapse-condense ion-toolbar:first-of-type {
+  /**
+   * The toolbar that contains the collapsible
+   * large title should not have safe area padding applied.
+   */
+  padding-top: 0px;
+  z-index: 1;
+}
+
+/**
+ * Large title toolbar should just use the content background
+ * since it needs to blend in with the header above it.
+ */
+.header-collapse-condense ion-toolbar {
+  z-index: 0;
+}
+
+.header-collapse-condense ion-toolbar:last-of-type {
+  --border-width: 0px;
+}
+
+.header-collapse-condense ion-toolbar ion-searchbar {
+  padding-top: 0px;
+  padding-bottom: 13px;
+}
+
+.header-collapse-main {
+  --opacity-scale: 1;
+}
+
+.header-collapse-main ion-toolbar {
+  --opacity-scale: inherit;
+}
+
+.header-collapse-main ion-toolbar.in-toolbar ion-title,
+.header-collapse-main ion-toolbar.in-toolbar ion-buttons {
+  transition: all 0.2s ease-in-out;
+}
+
+/**
+ * Large title toolbar should just use the content background
+ * since it needs to blend in with the header above it.
+ */
+.header-collapse-condense ion-toolbar,
+.header-collapse-condense-inactive.header-transitioning:not(.header-collapse-condense) ion-toolbar {
+  --background: var(--ion-background-color, #fff);
+}
+
+/**
+ * Override styles applied during the page transition to prevent
+ * header flickering.
+ */
+.header-collapse-condense-inactive.header-transitioning:not(.header-collapse-condense) ion-toolbar {
+  --border-style: none;
+  --opacity-scale: 1;
+}
+
+.header-collapse-condense-inactive:not(.header-collapse-condense) ion-toolbar.in-toolbar ion-title,
+.header-collapse-condense-inactive:not(.header-collapse-condense) ion-toolbar.in-toolbar ion-buttons.buttons-collapse {
+  opacity: 0;
+  pointer-events: none;
+}
+
+/**
+ * There is a bug in Safari where changing
+ * the opacity of an element in a scrollable container
+ * while rubber-banding causes the scroll position
+ * to jump to the top
+ */
+.header-collapse-condense-inactive.header-collapse-condense ion-toolbar.in-toolbar ion-title,
+.header-collapse-condense-inactive.header-collapse-condense ion-toolbar.in-toolbar ion-buttons.buttons-collapse {
+  visibility: hidden;
+}
+
+/**
+ * The main header is only hidden once the collapsible large
+ * title is configured. As a result, if the main header loads
+ * before the collapsible large title is configured then the
+ * main header will be visible briefly before being hidden
+ * by the collapsible large title.
+ *
+ * The following selector ensures that any main header
+ * on a page with a collapsible large title is hidden
+ * before the collapsible large title is configured.
+ * Once the collapsible large title is configured the main
+ * header will have the ".header-collapse-main" class, and
+ * this selector will no longer apply.
+ *
+ * The :has(...) part of the selector ensures a couple things:
+ * 1. This will only apply within a page view since the content
+ * must be a subsequent-sibling of the header (~ ion-content).
+ * 2. This will only apply when that content has an active condense
+ *    header (the .header-collapse-condense class).
+ *
+ * We use opacity: 0 to avoid a layout shift.
+ * We use the class (not the attribute) because the class is only
+ * added when the condense effect is valid (large title present).
+ * The attribute alone is not sufficient since it would match even
+ * when the effect is guarded (e.g. no large title).
+ */
+ion-header:not(.header-collapse-main):has(~ ion-content ion-header.header-collapse-condense) {
+  opacity: 0;
+}
+
+/**
+ * The deprecated collapse="condense" prop is iOS-only.
+ * On non-iOS themes, the condense header should be hidden since
+ * the JS won't activate it. Uses a class instead of an attribute
+ * selector because collapse is not a reflected prop, and framework
+ * proxies (Angular/Vue) bind it as a property.
+ */
+.header-collapse-condense-hidden {
+  display: none;
+}
+
+ion-header.header-scroll-effect-hide {
+  transition: transform 300ms cubic-bezier(0, 0, 0.2, 1), opacity 300ms cubic-bezier(0, 0, 0.2, 1);
+}
+
+ion-header.header-scroll-effect-hide.header-scroll-hidden {
+  transform: translateY(-100%);
+  transition: transform 200ms cubic-bezier(0.4, 0, 1, 1), opacity 300ms cubic-bezier(0.4, 0, 1, 1);
+  opacity: 0;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  ion-header.header-scroll-effect-hide,
+  ion-header.header-scroll-effect-hide.header-scroll-hidden {
+    transition: none;
+  }
+}
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use
@@ -54,17 +224,15 @@
  * }
  */
 ion-header {
-  display: block;
-  position: relative;
-  order: -1;
-  width: 100%;
   z-index: 10;
 }
 
-ion-header ion-toolbar:first-of-type {
-  padding-top: var(--ion-safe-area-top, 0);
-}
-
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use
@@ -124,8 +292,30 @@ ion-header ion-toolbar:first-of-type {
   box-shadow: 0 2px 4px -1px rgba(0, 0, 0, 0.2), 0 4px 5px 0 rgba(0, 0, 0, 0.14), 0 1px 10px 0 rgba(0, 0, 0, 0.12);
 }
 
+/**
+ * The condense header should blend seamlessly with the
+ * main header above it, so remove the box-shadow.
+ */
 .header-md.header-collapse-condense {
-  display: none;
+  box-shadow: none;
+}
+
+/**
+ * When the condense header is active (large title visible),
+ * the main header's box-shadow should be hidden so it blends
+ * with the condense header below it.
+ */
+.header-md.header-collapse-condense-inactive:not(.header-collapse-condense) {
+  box-shadow: none;
+}
+
+/**
+ * The fade effect fades the toolbar background via --opacity-scale,
+ * but box-shadow is not affected by that variable. Remove it so
+ * the shadow doesn't persist when the background is faded out.
+ */
+.header-md.header-collapse-fade {
+  box-shadow: none;
 }
 
 .header-md.ion-no-border {

package/dist/collection/components/header/header.utils.js

@@ -50,13 +50,14 @@ export const handleContentScroll = (scrollEl, scrollHeaderIndex, contentEl) => {
     });
 };
 export const setToolbarBackgroundOpacity = (headerEl, opacity) => {
+    var _a;
     /**
      * Fading in the backdrop opacity
      * should happen after the large title
      * has collapsed, so it is handled
      * by handleHeaderFade()
      */
-    if (headerEl.collapse === 'fade') {
+    if (((_a = headerEl.scrollEffect) !== null && _a !== void 0 ? _a : headerEl.collapse) === 'fade') {
         return;
     }
     if (opacity === undefined) {
@@ -214,23 +215,15 @@ export const handleHeaderFade = (scrollEl, baseEl, condenseHeader) => {
  * Get the role type for the ion-header.
  *
  * @param isInsideMenu If ion-header is inside ion-menu.
- * @param isCondensed If ion-header has collapse="condense".
- * @param mode The current mode.
- * @returns 'none' if inside ion-menu or if condensed in md
- * mode, otherwise 'banner'.
+ * @returns 'none' if inside ion-menu, otherwise 'banner'.
+ * Condensed headers start as 'banner' and have their role
+ * toggled dynamically by setHeaderActive() on scroll.
  */
-export const getRoleType = (isInsideMenu, isCondensed, mode) => {
+export const getRoleType = (isInsideMenu) => {
     // If the header is inside a menu, it should not have the banner role.
     if (isInsideMenu) {
         return ROLE_NONE;
     }
-    /**
-     * Only apply role="none" to `md` mode condensed headers
-     * since the large header is never shown.
-     */
-    if (isCondensed && mode === 'md') {
-        return ROLE_NONE;
-    }
     // Default to banner role.
     return ROLE_BANNER;
 };