voyager-ionic-core 8.0.1 → 8.1.0

package/dist/collection/utils/focus-controller/index.js

@@ -0,0 +1,112 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { config } from "../../global/config";
+import { printIonWarning } from "../logging/index";
+/**
+ * Moves focus to a specified element. Note that we do not remove the tabindex
+ * because that can result in an unintentional blur. Non-focusables can't be
+ * focused, so the body will get focused again.
+ */
+const moveFocus = (el) => {
+    el.tabIndex = -1;
+    el.focus();
+};
+/**
+ * Elements that are hidden using `display: none` should not be focused even if
+ * they are present in the DOM.
+ */
+const isVisible = (el) => {
+    return el.offsetParent !== null;
+};
+/**
+ * The focus controller allows us to manage focus within a view so assistive
+ * technologies can inform users of changes to the navigation state. Traditional
+ * native apps have a way of informing assistive technology about a navigation
+ * state change. Mobile browsers have this too, but only when doing a full page
+ * load. In a single page app we do not do that, so we need to build this
+ * integration ourselves.
+ */
+export const createFocusController = () => {
+    const saveViewFocus = (referenceEl) => {
+        const focusManagerEnabled = config.get('focusManagerPriority', false);
+        /**
+         * When going back to a previously visited page focus should typically be moved
+         * back to the element that was last focused when the user was on this view.
+         */
+        if (focusManagerEnabled) {
+            const activeEl = document.activeElement;
+            if (activeEl !== null && (referenceEl === null || referenceEl === void 0 ? void 0 : referenceEl.contains(activeEl))) {
+                activeEl.setAttribute(LAST_FOCUS, 'true');
+            }
+        }
+    };
+    const setViewFocus = (referenceEl) => {
+        const focusManagerPriorities = config.get('focusManagerPriority', false);
+        /**
+         * If the focused element is a descendant of the referenceEl then it's possible
+         * that the app developer manually moved focus, so we do not want to override that.
+         * This can happen with inputs the are focused when a view transitions in.
+         */
+        if (Array.isArray(focusManagerPriorities) && !referenceEl.contains(document.activeElement)) {
+            /**
+             * When going back to a previously visited view focus should always be moved back
+             * to the element that the user was last focused on when they were on this view.
+             */
+            const lastFocus = referenceEl.querySelector(`[${LAST_FOCUS}]`);
+            if (lastFocus && isVisible(lastFocus)) {
+                moveFocus(lastFocus);
+                return;
+            }
+            for (const priority of focusManagerPriorities) {
+                /**
+                 * For each recognized case (excluding the default case) make sure to return
+                 * so that the fallback focus behavior does not run.
+                 *
+                 * We intentionally query for specific roles/semantic elements so that the
+                 * transition manager can work with both Ionic and non-Ionic UI components.
+                 *
+                 * If new selectors are added, be sure to remove the outline ring by adding
+                 * new selectors to rule in core.scss.
+                 */
+                switch (priority) {
+                    case 'content':
+                        const content = referenceEl.querySelector('main, [role="main"]');
+                        if (content && isVisible(content)) {
+                            moveFocus(content);
+                            return;
+                        }
+                        break;
+                    case 'heading':
+                        const headingOne = referenceEl.querySelector('h1, [role="heading"][aria-level="1"]');
+                        if (headingOne && isVisible(headingOne)) {
+                            moveFocus(headingOne);
+                            return;
+                        }
+                        break;
+                    case 'banner':
+                        const header = referenceEl.querySelector('header, [role="banner"]');
+                        if (header && isVisible(header)) {
+                            moveFocus(header);
+                            return;
+                        }
+                        break;
+                    default:
+                        printIonWarning(`Unrecognized focus manager priority value ${priority}`);
+                        break;
+                }
+            }
+            /**
+             * If there is nothing to focus then focus the page so focus at least moves to
+             * the correct view. The browser will then determine where within the page to
+             * move focus to.
+             */
+            moveFocus(referenceEl);
+        }
+    };
+    return {
+        saveViewFocus,
+        setViewFocus,
+    };
+};
+const LAST_FOCUS = 'ion-last-focus';

package/dist/collection/utils/focus-controller/test/generic/focus-controller.e2e.js

@@ -0,0 +1,52 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { expect } from "@playwright/test";
+import { configs, test } from "../../../test/playwright/index";
+configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
+    test.describe(title('focus controller: generic components'), () => {
+        test.beforeEach(async ({ page }) => {
+            await page.goto('/src/utils/focus-controller/test/generic', config);
+        });
+        test('should focus heading', async ({ page }) => {
+            const goToPageOneButton = page.locator('page-root button.page-one');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            // Focus heading on Page One
+            await goToPageOneButton.click();
+            await ionNavDidChange.next();
+            const pageOneTitle = page.locator('page-one h1');
+            await expect(pageOneTitle).toBeFocused();
+        });
+        test('should focus banner', async ({ page }) => {
+            const goToPageThreeButton = page.locator('page-root button.page-three');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            const pageThreeHeader = page.locator('page-three header');
+            await goToPageThreeButton.click();
+            await ionNavDidChange.next();
+            await expect(pageThreeHeader).toBeFocused();
+        });
+        test('should focus content', async ({ page }) => {
+            const goToPageTwoButton = page.locator('page-root button.page-two');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            const pageTwoContent = page.locator('page-two main');
+            await goToPageTwoButton.click();
+            await ionNavDidChange.next();
+            await expect(pageTwoContent).toBeFocused();
+        });
+        test('should return focus when going back', async ({ page, browserName }) => {
+            test.skip(browserName === 'webkit', 'Desktop Safari does not consider buttons to be focusable');
+            const goToPageOneButton = page.locator('page-root button.page-one');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            const pageOneBackButton = page.locator('page-one ion-back-button');
+            await goToPageOneButton.click();
+            await ionNavDidChange.next();
+            await pageOneBackButton.click();
+            await ionNavDidChange.next();
+            await expect(goToPageOneButton).toBeFocused();
+        });
+    });
+});

package/dist/collection/utils/focus-controller/test/ionic/focus-controller.e2e.js

@@ -0,0 +1,52 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { expect } from "@playwright/test";
+import { configs, test } from "../../../test/playwright/index";
+configs({ modes: ['md'], directions: ['ltr'] }).forEach(({ title, config }) => {
+    test.describe(title('focus controller: ionic components'), () => {
+        test.beforeEach(async ({ page }) => {
+            await page.goto('/src/utils/focus-controller/test/ionic', config);
+        });
+        test('should focus heading', async ({ page }) => {
+            const goToPageOneButton = page.locator('page-root ion-button.page-one');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            // Focus heading on Page One
+            await goToPageOneButton.click();
+            await ionNavDidChange.next();
+            const pageOneTitle = page.locator('page-one ion-title');
+            await expect(pageOneTitle).toBeFocused();
+        });
+        test('should focus banner', async ({ page }) => {
+            const goToPageThreeButton = page.locator('page-root ion-button.page-three');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            const pageThreeHeader = page.locator('page-three ion-header');
+            await goToPageThreeButton.click();
+            await ionNavDidChange.next();
+            await expect(pageThreeHeader).toBeFocused();
+        });
+        test('should focus content', async ({ page }) => {
+            const goToPageTwoButton = page.locator('page-root ion-button.page-two');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            const pageTwoContent = page.locator('page-two ion-content');
+            await goToPageTwoButton.click();
+            await ionNavDidChange.next();
+            await expect(pageTwoContent).toBeFocused();
+        });
+        test('should return focus when going back', async ({ page, browserName }) => {
+            test.skip(browserName === 'webkit', 'Desktop Safari does not consider buttons to be focusable');
+            const goToPageOneButton = page.locator('page-root ion-button.page-one');
+            const nav = page.locator('ion-nav');
+            const ionNavDidChange = await nav.spyOnEvent('ionNavDidChange');
+            const pageOneBackButton = page.locator('page-one ion-back-button');
+            await goToPageOneButton.click();
+            await ionNavDidChange.next();
+            await pageOneBackButton.click();
+            await ionNavDidChange.next();
+            await expect(goToPageOneButton).toBeFocused();
+        });
+    });
+});

package/dist/collection/utils/overlays.js

@@ -152,7 +152,7 @@ const trapKeyboardFocus = (ev, doc) => {
      * behind the sheet should be focusable until
      * the backdrop is enabled.
      */
-    if (lastOverlay.classList.contains('ion-disable-focus-trap')) {
+    if (lastOverlay.classList.contains(FOCUS_TRAP_DISABLE_CLASS)) {
         return;
     }
     const trapScopedFocus = () => {
@@ -827,3 +827,4 @@ const revealOverlaysToScreenReaders = () => {
         }
     }
 };
+export const FOCUS_TRAP_DISABLE_CLASS = 'ion-disable-focus-trap';

package/dist/collection/utils/transition/index.js

@@ -1,11 +1,14 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
+import { config } from "../../global/config";
 import { Build, writeTask } from "@stencil/core";
 import { LIFECYCLE_DID_ENTER, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_ENTER, LIFECYCLE_WILL_LEAVE, } from "../../components/nav/constants";
+import { createFocusController } from "../focus-controller";
 import { raf } from "../helpers";
 const iosTransitionAnimation = () => import('./ios.transition');
 const mdTransitionAnimation = () => import('./md.transition');
+const focusController = createFocusController();
 // TODO(FW-2832): types
 export const transition = (opts) => {
     return new Promise((resolve, reject) => {
@@ -27,6 +30,7 @@ export const transition = (opts) => {
 const beforeTransition = (opts) => {
     const enteringEl = opts.enteringEl;
     const leavingEl = opts.leavingEl;
+    focusController.saveViewFocus(leavingEl);
     setZIndex(enteringEl, leavingEl, opts.direction);
     if (opts.showGoBack) {
         enteringEl.classList.add('can-go-back');
@@ -61,6 +65,7 @@ const afterTransition = (opts) => {
         leavingEl.classList.remove('ion-page-invisible');
         leavingEl.style.removeProperty('pointer-events');
     }
+    focusController.setViewFocus(enteringEl);
 };
 const getAnimationBuilder = async (opts) => {
     if (!opts.leavingEl || !opts.animated || opts.duration === 0) {
@@ -93,7 +98,12 @@ const animation = async (animationBuilder, opts) => {
 const noAnimation = async (opts) => {
     const enteringEl = opts.enteringEl;
     const leavingEl = opts.leavingEl;
-    await waitForReady(opts, false);
+    const focusManagerEnabled = config.get('focusManagerPriority', false);
+    /**
+     * If the focus manager is enabled then we need to wait for Ionic components to be
+     * rendered otherwise the component to focus may not be focused because it is hidden.
+     */
+    await waitForReady(opts, focusManagerEnabled);
     fireWillEvents(enteringEl, leavingEl);
     fireDidEvents(enteringEl, leavingEl);
     return {

package/dist/collection/utils/transition/ios.transition.js

@@ -55,20 +55,22 @@ const createLargeTitleTransition = (rootAnimation, rtl, backDirection, enteringE
         const leavingLargeTitleBox = leavingLargeTitle.getBoundingClientRect();
         const enteringBackButtonBox = enteringBackButton.getBoundingClientRect();
         const enteringBackButtonTextEl = shadow(enteringBackButton).querySelector('.button-text');
-        const enteringBackButtonTextBox = enteringBackButtonTextEl.getBoundingClientRect();
+        // Text element not rendered if developers pass text="" to the back button
+        const enteringBackButtonTextBox = enteringBackButtonTextEl === null || enteringBackButtonTextEl === void 0 ? void 0 : enteringBackButtonTextEl.getBoundingClientRect();
         const leavingLargeTitleTextEl = shadow(leavingLargeTitle).querySelector('.toolbar-title');
         const leavingLargeTitleTextBox = leavingLargeTitleTextEl.getBoundingClientRect();
-        animateLargeTitle(rootAnimation, rtl, backDirection, leavingLargeTitle, leavingLargeTitleBox, leavingLargeTitleTextBox, enteringBackButtonTextEl, enteringBackButtonTextBox);
+        animateLargeTitle(rootAnimation, rtl, backDirection, leavingLargeTitle, leavingLargeTitleBox, leavingLargeTitleTextBox, enteringBackButtonBox, enteringBackButtonTextEl, enteringBackButtonTextBox);
         animateBackButton(rootAnimation, rtl, backDirection, enteringBackButton, enteringBackButtonBox, enteringBackButtonTextEl, enteringBackButtonTextBox, leavingLargeTitle, leavingLargeTitleTextBox);
     }
     else if (shouldAnimationBackward) {
         const enteringLargeTitleBox = enteringLargeTitle.getBoundingClientRect();
         const leavingBackButtonBox = leavingBackButton.getBoundingClientRect();
         const leavingBackButtonTextEl = shadow(leavingBackButton).querySelector('.button-text');
-        const leavingBackButtonTextBox = leavingBackButtonTextEl.getBoundingClientRect();
+        // Text element not rendered if developers pass text="" to the back button
+        const leavingBackButtonTextBox = leavingBackButtonTextEl === null || leavingBackButtonTextEl === void 0 ? void 0 : leavingBackButtonTextEl.getBoundingClientRect();
         const enteringLargeTitleTextEl = shadow(enteringLargeTitle).querySelector('.toolbar-title');
         const enteringLargeTitleTextBox = enteringLargeTitleTextEl.getBoundingClientRect();
-        animateLargeTitle(rootAnimation, rtl, backDirection, enteringLargeTitle, enteringLargeTitleBox, enteringLargeTitleTextBox, leavingBackButtonTextEl, leavingBackButtonTextBox);
+        animateLargeTitle(rootAnimation, rtl, backDirection, enteringLargeTitle, enteringLargeTitleBox, enteringLargeTitleTextBox, leavingBackButtonBox, leavingBackButtonTextEl, leavingBackButtonTextBox);
         animateBackButton(rootAnimation, rtl, backDirection, leavingBackButton, leavingBackButtonBox, leavingBackButtonTextEl, leavingBackButtonTextBox, enteringLargeTitle, enteringLargeTitleTextBox);
     }
     return {
@@ -82,26 +84,31 @@ const animateBackButton = (rootAnimation, rtl, backDirection, backButtonEl, back
     const TEXT_ORIGIN_X = rtl ? 'right' : 'left';
     const ICON_ORIGIN_X = rtl ? 'left' : 'right';
     const CONTAINER_ORIGIN_X = rtl ? 'right' : 'left';
-    /**
-     * When the title and back button texts match
-     * then they should overlap during the page transition.
-     * If the texts do not match up then the back button text scale adjusts
-     * to not perfectly match the large title text otherwise the
-     * proportions will be incorrect.
-     * When the texts match we scale both the width and height to account for
-     * font weight differences between the title and back button.
-     */
-    const doTitleAndButtonTextsMatch = ((_a = backButtonTextEl.textContent) === null || _a === void 0 ? void 0 : _a.trim()) === ((_b = largeTitleEl.textContent) === null || _b === void 0 ? void 0 : _b.trim());
-    const WIDTH_SCALE = largeTitleTextBox.width / backButtonTextBox.width;
-    /**
-     * We subtract an offset to account for slight sizing/padding
-     * differences between the title and the back button.
-     */
-    const HEIGHT_SCALE = (largeTitleTextBox.height - LARGE_TITLE_SIZE_OFFSET) / backButtonTextBox.height;
-    const TEXT_START_SCALE = doTitleAndButtonTextsMatch
-        ? `scale(${WIDTH_SCALE}, ${HEIGHT_SCALE})`
-        : `scale(${HEIGHT_SCALE})`;
+    let WIDTH_SCALE = 1;
+    let HEIGHT_SCALE = 1;
+    let TEXT_START_SCALE = `scale(${HEIGHT_SCALE})`;
     const TEXT_END_SCALE = 'scale(1)';
+    if (backButtonTextEl && backButtonTextBox) {
+        /**
+         * When the title and back button texts match then they should overlap during the
+         * page transition. If the texts do not match up then the back button text scale
+         * adjusts to not perfectly match the large title text otherwise the proportions
+         * will be incorrect. When the texts match we scale both the width and height to
+         * account for font weight differences between the title and back button.
+         */
+        const doTitleAndButtonTextsMatch = ((_a = backButtonTextEl.textContent) === null || _a === void 0 ? void 0 : _a.trim()) === ((_b = largeTitleEl.textContent) === null || _b === void 0 ? void 0 : _b.trim());
+        WIDTH_SCALE = largeTitleTextBox.width / backButtonTextBox.width;
+        /**
+         * Subtract an offset to account for slight sizing/padding differences between the
+         * title and the back button.
+         */
+        HEIGHT_SCALE = (largeTitleTextBox.height - LARGE_TITLE_SIZE_OFFSET) / backButtonTextBox.height;
+        /**
+         * Even though we set TEXT_START_SCALE to HEIGHT_SCALE above, we potentially need
+         * to re-compute this here since the HEIGHT_SCALE may have changed.
+         */
+        TEXT_START_SCALE = doTitleAndButtonTextsMatch ? `scale(${WIDTH_SCALE}, ${HEIGHT_SCALE})` : `scale(${HEIGHT_SCALE})`;
+    }
     const backButtonIconEl = shadow(backButtonEl).querySelector('ion-icon');
     const backButtonIconBox = backButtonIconEl.getBoundingClientRect();
     /**
@@ -198,11 +205,11 @@ const animateBackButton = (rootAnimation, rtl, backDirection, backButtonEl, back
         top: '0px',
         [CONTAINER_ORIGIN_X]: '0px',
     })
-        .keyframes(CONTAINER_KEYFRAMES);
-    enteringBackButtonTextAnimation
-        .beforeStyles({
-        'transform-origin': `${TEXT_ORIGIN_X} top`,
-    })
+        /**
+         * The write hooks must be set on this animation as it is guaranteed to run. Other
+         * animations such as the back button text animation will not run if the back button
+         * has no visible text.
+         */
         .beforeAddWrite(() => {
         backButtonEl.style.setProperty('display', 'none');
         clonedBackButtonEl.style.setProperty(TEXT_ORIGIN_X, BACK_BUTTON_START_OFFSET);
@@ -211,6 +218,11 @@ const animateBackButton = (rootAnimation, rtl, backDirection, backButtonEl, back
         backButtonEl.style.setProperty('display', '');
         clonedBackButtonEl.style.setProperty('display', 'none');
         clonedBackButtonEl.style.removeProperty(TEXT_ORIGIN_X);
+    })
+        .keyframes(CONTAINER_KEYFRAMES);
+    enteringBackButtonTextAnimation
+        .beforeStyles({
+        'transform-origin': `${TEXT_ORIGIN_X} top`,
     })
         .keyframes(TEXT_KEYFRAMES);
     enteringBackButtonIconAnimation
@@ -224,7 +236,7 @@ const animateBackButton = (rootAnimation, rtl, backDirection, backButtonEl, back
         enteringBackButtonAnimation,
     ]);
 };
-const animateLargeTitle = (rootAnimation, rtl, backDirection, largeTitleEl, largeTitleBox, largeTitleTextBox, backButtonTextEl, backButtonTextBox) => {
+const animateLargeTitle = (rootAnimation, rtl, backDirection, largeTitleEl, largeTitleBox, largeTitleTextBox, backButtonBox, backButtonTextEl, backButtonTextBox) => {
     var _a, _b;
     /**
      * The horizontal transform origin for the large title
@@ -244,52 +256,67 @@ const animateLargeTitle = (rootAnimation, rtl, backDirection, largeTitleEl, larg
      * title and the back button due to padding and font weight.
      */
     const LARGE_TITLE_TRANSLATION_OFFSET = 8;
+    let END_TRANSLATE_X = rtl
+        ? `-${window.innerWidth - backButtonBox.right - LARGE_TITLE_TRANSLATION_OFFSET}px`
+        : `${backButtonBox.x + LARGE_TITLE_TRANSLATION_OFFSET}px`;
     /**
-     * The scaled title should (roughly) overlap the back button.
-     * This ensures that the back button and title overlap during
-     * the animation. Note that since both elements either fade in
-     * or fade out over the course of the animation, neither element
-     * will be fully visible on top of the other. As a result, the overlap
-     * does not need to be perfect, so approximate values are acceptable here.
+     * How much to scale the large title up/down by.
      */
-    const END_TRANSLATE_X = rtl
-        ? `-${window.innerWidth - backButtonTextBox.right - LARGE_TITLE_TRANSLATION_OFFSET}px`
-        : `${backButtonTextBox.x - LARGE_TITLE_TRANSLATION_OFFSET}px`;
+    let HEIGHT_SCALE = 0.5;
     /**
-     * The top of the scaled large title
-     * should match with the top of the
-     * back button text element.
-     * We subtract 2px to account for the top padding
-     * on the large title element.
+     * The large title always starts full size.
      */
-    const LARGE_TITLE_TOP_PADDING = 2;
-    const END_TRANSLATE_Y = `${backButtonTextBox.y - LARGE_TITLE_TOP_PADDING}px`;
+    const START_SCALE = 'scale(1)';
     /**
-     * In the forward direction, the large title should start at its
-     * normal size and then scale down to be (roughly) the size of the
-     * back button on the other view. In the backward direction, the
-     * large title should start at (roughly) the size of the back button
-     * and then scale up to its original size.
-     *
-     * Note that since both elements either fade in
-     * or fade out over the course of the animation, neither element
-     * will be fully visible on top of the other. As a result, the overlap
-     * does not need to be perfect, so approximate values are acceptable here.
+     * By default, we don't worry about having the large title scaled to perfectly
+     * match the back button because we don't know if the back button's text matches
+     * the large title's text.
      */
+    let END_SCALE = `scale(${HEIGHT_SCALE})`;
+    // Text element not rendered if developers pass text="" to the back button
+    if (backButtonTextEl && backButtonTextBox) {
+        /**
+         * The scaled title should (roughly) overlap the back button. This ensures that
+         * the back button and title overlap during the animation. Note that since both
+         * elements either fade in or fade out over the course of the animation, neither
+         * element will be fully visible on top of the other. As a result, the overlap
+         * does not need to be perfect, so approximate values are acceptable here.
+         */
+        END_TRANSLATE_X = rtl
+            ? `-${window.innerWidth - backButtonTextBox.right - LARGE_TITLE_TRANSLATION_OFFSET}px`
+            : `${backButtonTextBox.x - LARGE_TITLE_TRANSLATION_OFFSET}px`;
+        /**
+         * In the forward direction, the large title should start at its normal size and
+         * then scale down to be (roughly) the size of the back button on the other view.
+         * In the backward direction, the large title should start at (roughly) the size
+         * of the back button and then scale up to its original size.
+         * Note that since both elements either fade in or fade out over the course of the
+         * animation, neither element will be fully visible on top of the other. As a result,
+         * the overlap  does not need to be perfect, so approximate values are acceptable here.
+         */
+        /**
+         * When the title and back button texts match then they should overlap during the
+         * page transition. If the texts do not match up then the large title text scale
+         * adjusts to not perfectly match the back button text otherwise the proportions
+         * will be incorrect. When the texts match we scale both the width and height to
+         * account for font weight differences between the title and back button.
+         */
+        const doTitleAndButtonTextsMatch = ((_a = backButtonTextEl.textContent) === null || _a === void 0 ? void 0 : _a.trim()) === ((_b = largeTitleEl.textContent) === null || _b === void 0 ? void 0 : _b.trim());
+        const WIDTH_SCALE = backButtonTextBox.width / largeTitleTextBox.width;
+        HEIGHT_SCALE = backButtonTextBox.height / (largeTitleTextBox.height - LARGE_TITLE_SIZE_OFFSET);
+        /**
+         * Even though we set TEXT_START_SCALE to HEIGHT_SCALE above, we potentially need
+         * to re-compute this here since the HEIGHT_SCALE may have changed.
+         */
+        END_SCALE = doTitleAndButtonTextsMatch ? `scale(${WIDTH_SCALE}, ${HEIGHT_SCALE})` : `scale(${HEIGHT_SCALE})`;
+    }
     /**
-     * When the title and back button texts match
-     * then they should overlap during the page transition.
-     * If the texts do not match up then the large title text scale adjusts
-     * to not perfectly match the back button text otherwise the
-     * proportions will be incorrect.
-     * When the texts match we scale both the width and height to account for
-     * font weight differences between the title and back button.
+     * The midpoints of the back button and the title should align such that the back
+     * button and title appear to be centered with each other.
      */
-    const doTitleAndButtonTextsMatch = ((_a = backButtonTextEl.textContent) === null || _a === void 0 ? void 0 : _a.trim()) === ((_b = largeTitleEl.textContent) === null || _b === void 0 ? void 0 : _b.trim());
-    const WIDTH_SCALE = backButtonTextBox.width / largeTitleTextBox.width;
-    const HEIGHT_SCALE = backButtonTextBox.height / (largeTitleTextBox.height - LARGE_TITLE_SIZE_OFFSET);
-    const START_SCALE = 'scale(1)';
-    const END_SCALE = doTitleAndButtonTextsMatch ? `scale(${WIDTH_SCALE}, ${HEIGHT_SCALE})` : `scale(${HEIGHT_SCALE})`;
+    const backButtonMidPoint = backButtonBox.top + backButtonBox.height / 2;
+    const titleMidPoint = (largeTitleBox.height * HEIGHT_SCALE) / 2;
+    const END_TRANSLATE_Y = `${backButtonMidPoint - titleMidPoint}px`;
     const BACKWARDS_KEYFRAMES = [
         { offset: 0, opacity: 0, transform: `translate3d(${END_TRANSLATE_X}, ${END_TRANSLATE_Y}, 0) ${END_SCALE}` },
         { offset: 0.1, opacity: 0 },