@ionic/core 8.0.0-dev.11711035263.183d2423 → 8.0.0-dev.11711476529.17eae6ec

package/dist/collection/global/ionic-global.js

@@ -1,13 +1,120 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import { getMode, setMode, setPlatformHelpers } from "@stencil/core";
+import { getMode, setMode, setPlatformHelpers, getElement } from "@stencil/core";
+import { printIonWarning } from "../utils/logging/index";
 import { isPlatform, setupPlatforms } from "../utils/platform";
 import { config, configFromSession, configFromURL, saveConfig } from "./config";
-// TODO(FW-2832): types
 let defaultMode;
-export const getIonMode = (ref) => {
-    return (ref && getMode(ref)) || defaultMode;
+let defaultTheme = 'md';
+/**
+ * Prints a warning message to the developer to inform them of
+ * an invalid configuration of mode and theme.
+ * @param mode The invalid mode configuration.
+ * @param theme The invalid theme configuration.
+ */
+const printInvalidModeWarning = (mode, theme, ref) => {
+    printIonWarning(`Invalid mode and theme combination provided: mode: ${mode}, theme: ${theme}. Fallback mode ${getDefaultModeForTheme(theme)} will be used.`, ref);
+};
+/**
+ * Validates if a mode is accepted for a theme configuration.
+ * @param mode The mode to validate.
+ * @param theme The theme the mode is being used with.
+ * @returns `true` if the mode is valid for the theme, `false` if invalid.
+ */
+export const isModeValidForTheme = (mode, theme) => {
+    if (mode === 'md') {
+        return theme === 'md' || theme === 'ionic';
+    }
+    else if (mode === 'ios') {
+        return theme === 'ios' || theme === 'ionic';
+    }
+    return false;
+};
+/**
+ * Returns the default mode for a specified theme.
+ * @param theme The theme to return a default mode for.
+ * @returns The default mode, either `ios` or `md`.
+ */
+const getDefaultModeForTheme = (theme) => {
+    if (theme === 'ios') {
+        return 'ios';
+    }
+    return 'md';
+};
+/**
+ * Returns the default theme for a specified mode.
+ * @param mode The mode to return a default theme for.
+ * @returns The default theme.
+ */
+const getDefaultThemeForMode = (mode) => {
+    if (mode === 'ios') {
+        return 'ios';
+    }
+    return 'md';
+};
+const isModeSupported = (elmMode) => ['ios', 'md'].includes(elmMode);
+const isThemeSupported = (theme) => ['ios', 'md', 'ionic'].includes(theme);
+const isIonicElement = (elm) => { var _a; return (_a = elm.tagName) === null || _a === void 0 ? void 0 : _a.startsWith('ION-'); };
+/**
+ * Returns the mode value of the element reference or the closest
+ * parent with a valid mode.
+ * @param ref The element reference to look up the mode for.
+ * @param theme Optionally can provide the theme to avoid an additional look-up.
+ * @returns The mode value for the element reference.
+ */
+export const getIonMode = (ref, theme = getIonTheme(ref)) => {
+    var _a;
+    if ((ref === null || ref === void 0 ? void 0 : ref.mode) && isModeValidForTheme(ref === null || ref === void 0 ? void 0 : ref.mode, theme)) {
+        /**
+         * If the reference already has a mode configuration,
+         * use it instead of performing a look-up.
+         */
+        return ref.mode;
+    }
+    else {
+        const el = getElement(ref);
+        const mode = ((_a = el.closest('[mode]')) === null || _a === void 0 ? void 0 : _a.getAttribute('mode')) || defaultMode;
+        if (isModeValidForTheme(mode, theme)) {
+            /**
+             * The mode configuration is supported for the configured theme.
+             */
+            return mode;
+        }
+        else {
+            printInvalidModeWarning(mode, theme, ref);
+        }
+    }
+    return getDefaultModeForTheme(theme);
+};
+/**
+ * Returns the theme value of the element reference or the closest
+ * parent with a valid theme.
+ *
+ * @param ref The element reference to look up the theme for.
+ * @returns The theme value for the element reference, defaults to
+ * the default theme if it cannot be determined.
+ */
+export const getIonTheme = (ref) => {
+    var _a, _b;
+    const theme = ref && getMode(ref);
+    if (theme) {
+        return theme;
+    }
+    /**
+     * If the theme cannot be detected, then fallback to using
+     * the `mode` attribute to determine the style sheets to use.
+     */
+    const el = getElement(ref);
+    const mode = (_a = ref === null || ref === void 0 ? void 0 : ref.mode) !== null && _a !== void 0 ? _a : (_b = el.closest('[mode]')) === null || _b === void 0 ? void 0 : _b.getAttribute('mode');
+    if (mode) {
+        return getDefaultThemeForMode(mode);
+    }
+    /**
+     * If a mode is not detected, then fallback to using the
+     * default theme.
+     */
+    return defaultTheme;
 };
 export const initialize = (userConfig = {}) => {
     if (typeof window === 'undefined') {
@@ -36,33 +143,74 @@ export const initialize = (userConfig = {}) => {
     }
     // Setup platforms
     setupPlatforms(win);
-    // first see if the mode was set as an attribute on <html>
-    // which could have been set by the user, or by pre-rendering
-    // otherwise get the mode via config settings, and fallback to md
     Ionic.config = config;
+    /**
+     * Check if the mode was set as an attribute on <html>
+     * which could have been set by the user, or by pre-rendering
+     * otherwise get the mode via config settings, and fallback to md.
+     */
     Ionic.mode = defaultMode = config.get('mode', doc.documentElement.getAttribute('mode') || (isPlatform(win, 'ios') ? 'ios' : 'md'));
+    /**
+     * Check if the theme was set as an attribute on <html>
+     * which could have been set by the user, or by pre-rendering
+     * otherwise get the theme via config settings, and fallback to md.
+     */
+    Ionic.theme = defaultTheme = config.get('theme', doc.documentElement.getAttribute('theme') || getDefaultThemeForMode(defaultMode));
+    if (!isModeValidForTheme(defaultMode, defaultTheme)) {
+        printInvalidModeWarning(defaultMode, defaultTheme, configObj);
+        defaultMode = getDefaultModeForTheme(defaultTheme);
+    }
     config.set('mode', defaultMode);
     doc.documentElement.setAttribute('mode', defaultMode);
     doc.documentElement.classList.add(defaultMode);
+    config.set('theme', defaultTheme);
+    doc.documentElement.setAttribute('theme', defaultTheme);
+    doc.documentElement.classList.add(defaultTheme);
     if (config.getBoolean('_testing')) {
         config.set('animated', false);
     }
-    const isIonicElement = (elm) => { var _a; return (_a = elm.tagName) === null || _a === void 0 ? void 0 : _a.startsWith('ION-'); };
-    const isAllowedIonicModeValue = (elmMode) => ['ios', 'md'].includes(elmMode);
     setMode((elm) => {
+        /**
+         * Iterate over all the element nodes, to both validate and
+         * set the "mode" that is used for determining the styles to
+         * apply to the element.
+         *
+         * setMode refers to Stencil's internal metadata for "mode",
+         * which is used to set the correct styleUrl for the component.
+         *
+         * If the "theme" attribute or property is set, then use it
+         * to determine the style sheets to use.
+         *
+         * If the "mode" attribute or property is set, then use it
+         * to determine the style sheets to use. This is fallback
+         * behavior for applications that are not setting the "theme".
+         */
         while (elm) {
+            const theme = elm.theme || elm.getAttribute('theme');
+            if (theme) {
+                if (isThemeSupported(theme)) {
+                    return theme;
+                }
+                else if (isIonicElement(elm)) {
+                    printIonWarning(`Invalid theme: "${theme}". Supported themes include: "ios" or "md".`);
+                }
+            }
+            /**
+             * If a theme is not detected, then fallback to using the
+             * `mode` attribute to determine the style sheets to use.
+             */
             const elmMode = elm.mode || elm.getAttribute('mode');
             if (elmMode) {
-                if (isAllowedIonicModeValue(elmMode)) {
+                if (isModeSupported(elmMode)) {
                     return elmMode;
                 }
                 else if (isIonicElement(elm)) {
-                    console.warn('Invalid ionic mode: "' + elmMode + '", expected: "ios" or "md"');
+                    printIonWarning(`Invalid mode: "${elmMode}". Ionic modes can be only "ios" or "md"`);
                 }
             }
             elm = elm.parentElement;
         }
-        return defaultMode;
+        return defaultTheme;
     });
 };
 export default initialize;

package/dist/collection/global/test/ionic-global.spec.js

@@ -0,0 +1,109 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const getMode = jest.fn();
+const getElement = jest.fn();
+jest.mock('@stencil/core', () => {
+    const original = jest.requireActual('@stencil/core');
+    return Object.assign(Object.assign({}, original), { getMode,
+        getElement });
+});
+/**
+ * The implementation needs to be mocked before the implementation is imported.
+ */
+// eslint-disable-next-line import/first
+import { getIonTheme, isModeValidForTheme, getIonMode } from "../ionic-global";
+describe('Ionic Global', () => {
+    describe('isModeValidForTheme', () => {
+        it('should return true for md mode with md theme', () => {
+            expect(isModeValidForTheme('md', 'md')).toBe(true);
+        });
+        it('should return true for md mode with ionic theme', () => {
+            expect(isModeValidForTheme('md', 'ionic')).toBe(true);
+        });
+        it('should return true for ios mode with ios theme', () => {
+            expect(isModeValidForTheme('ios', 'ios')).toBe(true);
+        });
+        it('should return true for ios mode with ionic theme', () => {
+            expect(isModeValidForTheme('ios', 'ionic')).toBe(true);
+        });
+        it('should return false for md mode with ios theme', () => {
+            expect(isModeValidForTheme('md', 'ios')).toBe(false);
+        });
+        it('should return false for ios mode with md theme', () => {
+            expect(isModeValidForTheme('ios', 'md')).toBe(false);
+        });
+    });
+    describe('getIonMode', () => {
+        const parentRef = { mode: 'md' };
+        const ref = { parentElement: parentRef };
+        beforeEach(() => {
+            getMode.mockImplementation((ref) => { var _a; return (_a = ref.mode) !== null && _a !== void 0 ? _a : parentRef.mode; });
+            getElement.mockImplementation(() => ({
+                closest: () => ({
+                    getAttribute: () => parentRef.mode,
+                }),
+            }));
+        });
+        afterEach(() => {
+            getMode.mockReset();
+            getElement.mockReset();
+        });
+        it('should return the mode value of the element reference', () => {
+            const ref = { mode: 'ios' };
+            getMode.mockImplementation((ref) => ref.mode);
+            getElement.mockImplementation(() => ({
+                closest: () => ({
+                    getAttribute: () => ref.mode,
+                }),
+            }));
+            expect(getIonMode(ref, 'ios')).toBe('ios');
+        });
+        it('should return the mode value of the closest parent with a valid mode', () => {
+            expect(getIonMode(ref)).toBe('md');
+        });
+        it('should return the default mode if the mode cannot be determined', () => {
+            expect(getIonMode()).toBe('md');
+        });
+        it('should return the theme value if provided and no mode is found', () => {
+            const ref = { mode: undefined };
+            const theme = 'ios';
+            expect(getIonMode(ref, theme)).toBe('ios');
+        });
+    });
+    describe('getIonTheme', () => {
+        const parentRef = { mode: 'md' };
+        beforeEach(() => {
+            getMode.mockImplementation((ref) => { var _a; return (_a = ref === null || ref === void 0 ? void 0 : ref.mode) !== null && _a !== void 0 ? _a : parentRef.mode; });
+            getElement.mockImplementation(() => ({
+                closest: () => ({
+                    getAttribute: () => parentRef.mode,
+                }),
+            }));
+        });
+        afterEach(() => {
+            getMode.mockReset();
+            getElement.mockReset();
+        });
+        it('should return the theme value of the element reference', () => {
+            const ref = { mode: 'ios' };
+            expect(getIonTheme(ref)).toBe('ios');
+        });
+        it('should return the theme value of the closest parent with a valid theme', () => {
+            getElement.mockImplementation(() => ({
+                closest: () => ({
+                    getAttribute: () => 'ios',
+                }),
+            }));
+            expect(getIonTheme()).toBe('ios');
+        });
+        it('should return the default theme if it cannot be determined', () => {
+            getElement.mockImplementation(() => ({
+                closest: () => ({
+                    getAttribute: () => null,
+                }),
+            }));
+            expect(getIonTheme()).toBe('md');
+        });
+    });
+});

package/dist/collection/utils/menu-controller/animations/overlay.js

@@ -27,8 +27,8 @@ export const menuOverlayAnimation = (menu) => {
     }
     menuAnimation.addElement(menu.menuInnerEl).fromTo('transform', `translateX(${closedX})`, `translateX(${openedX})`);
     const mode = getIonMode(menu);
-    const isIos = mode === 'ios';
-    const opacity = isIos ? 0.2 : 0.25;
+    const isIOS = mode === 'ios';
+    const opacity = isIOS ? 0.2 : 0.25;
     backdropAnimation.addElement(menu.backdropEl).fromTo('opacity', 0.01, opacity);
-    return baseAnimation(isIos).addAnimation([menuAnimation, backdropAnimation]);
+    return baseAnimation(isIOS).addAnimation([menuAnimation, backdropAnimation]);
 };

package/dist/collection/utils/menu-controller/animations/push.js

@@ -14,6 +14,7 @@ export const menuPushAnimation = (menu) => {
     let menuClosedX;
     const mode = getIonMode(menu);
     const width = menu.width;
+    const isIOS = mode === 'ios';
     if (menu.isEndSide) {
         contentOpenedX = -width + 'px';
         menuClosedX = width + 'px';
@@ -29,5 +30,5 @@ export const menuPushAnimation = (menu) => {
         .addElement(menu.contentEl)
         .fromTo('transform', 'translateX(0px)', `translateX(${contentOpenedX})`);
     const backdropAnimation = createAnimation().addElement(menu.backdropEl).fromTo('opacity', 0.01, 0.32);
-    return baseAnimation(mode === 'ios').addAnimation([menuAnimation, contentAnimation, backdropAnimation]);
+    return baseAnimation(isIOS).addAnimation([menuAnimation, contentAnimation, backdropAnimation]);
 };

package/dist/collection/utils/menu-controller/animations/reveal.js

@@ -11,9 +11,10 @@ import { baseAnimation } from "./base";
  */
 export const menuRevealAnimation = (menu) => {
     const mode = getIonMode(menu);
+    const isIOS = mode === 'ios';
     const openedX = menu.width * (menu.isEndSide ? -1 : 1) + 'px';
     const contentOpen = createAnimation()
         .addElement(menu.contentEl) // REVIEW
         .fromTo('transform', 'translateX(0px)', `translateX(${openedX})`);
-    return baseAnimation(mode === 'ios').addAnimation(contentOpen);
+    return baseAnimation(isIOS).addAnimation(contentOpen);
 };

package/dist/collection/utils/tap-click/index.js

@@ -2,43 +2,17 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { doc } from "../browser/index";
-import { now, pointerCoord } from "../helpers";
+import { pointerCoord } from "../helpers";
 export const startTapClick = (config) => {
     if (doc === undefined) {
         return;
     }
-    let lastTouch = -MOUSE_WAIT * 10;
     let lastActivated = 0;
     let activatableEle;
     let activeRipple;
     let activeDefer;
     const useRippleEffect = config.getBoolean('animated', true) && config.getBoolean('rippleEffect', true);
     const clearDefers = new WeakMap();
-    // Touch Events
-    const onTouchStart = (ev) => {
-        lastTouch = now(ev);
-        pointerDown(ev);
-    };
-    const onTouchEnd = (ev) => {
-        lastTouch = now(ev);
-        pointerUp(ev);
-    };
-    const onMouseDown = (ev) => {
-        // Ignore right clicks
-        if (ev.button === 2) {
-            return;
-        }
-        const t = now(ev) - MOUSE_WAIT;
-        if (lastTouch < t) {
-            pointerDown(ev);
-        }
-    };
-    const onMouseUp = (ev) => {
-        const t = now(ev) - MOUSE_WAIT;
-        if (lastTouch < t) {
-            pointerUp(ev);
-        }
-    };
     const cancelActive = () => {
         if (activeDefer)
             clearTimeout(activeDefer);
@@ -49,7 +23,8 @@ export const startTapClick = (config) => {
         }
     };
     const pointerDown = (ev) => {
-        if (activatableEle) {
+        // Ignore right clicks
+        if (activatableEle || ev.button === 2) {
             return;
         }
         setActivatedElement(getActivatableTarget(ev), ev);
@@ -133,9 +108,8 @@ export const startTapClick = (config) => {
         }
     };
     doc.addEventListener('ionGestureCaptured', cancelActive);
-    doc.addEventListener('touchstart', onTouchStart, true);
-    doc.addEventListener('touchcancel', onTouchEnd, true);
-    doc.addEventListener('touchend', onTouchEnd, true);
+    doc.addEventListener('pointerdown', pointerDown, true);
+    doc.addEventListener('pointerup', pointerUp, true);
     /**
      * Tap click effects such as the ripple effect should
      * not happen when scrolling. For example, if a user scrolls
@@ -149,8 +123,6 @@ export const startTapClick = (config) => {
      * ion-content's scroll events.
      */
     doc.addEventListener('pointercancel', cancelActive, true);
-    doc.addEventListener('mousedown', onMouseDown, true);
-    doc.addEventListener('mouseup', onMouseUp, true);
 };
 // TODO(FW-2832): type
 const getActivatableTarget = (ev) => {
@@ -190,4 +162,3 @@ const getRippleEffect = (el) => {
 const ACTIVATED = 'ion-activated';
 const ADD_ACTIVATED_DEFERS = 100;
 const CLEAR_STATE_DEFERS = 150;
-const MOUSE_WAIT = 2500;

package/dist/collection/utils/test/playwright/generator.js

@@ -1,6 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
+import { isModeValidForTheme } from "../../../global/ionic-global";
 /**
  * Generates a unique test title based on a base title
  * and a test config. Playwright uses test titles to generate
@@ -8,53 +9,73 @@
  * each test title is unique.
  */
 const generateTitle = (title, config) => {
-    const { mode, direction, palette } = config;
-    if (palette === 'light') {
+    const { direction, palette, theme, mode } = config;
+    if (theme === mode) {
         /**
-         * Ionic has many existing tests that existed prior to
-         * the introduction of palette testing. To maintain backwards
-         * compatibility, we will not include the palette in the test
-         * title if the palette is set to light.
+         * Fallback to the old test title naming convention
+         * when the theme and mode are the same.
          */
-        return `${title} - ${mode}/${direction}`;
+        if (palette === 'light') {
+            /**
+             * Ionic has many existing tests that existed prior to
+             * the introduction of theme testing. To maintain backwards
+             * compatibility, we will not include the theme in the test
+             * title if the theme is set to light.
+             */
+            return `${title} - ${theme}/${direction}`;
+        }
+        return `${title} - ${theme}/${direction}/${palette}`;
     }
-    return `${title} - ${mode}/${direction}/${palette}`;
+    return `${title} - ${theme}/${mode}/${direction}/${palette}`;
 };
 /**
  * Generates a unique filename based on a base filename
  * and a test config.
  */
 const generateScreenshotName = (fileName, config) => {
-    const { mode, direction, palette } = config;
-    if (palette === 'light') {
+    const { theme, direction, palette, mode } = config;
+    if (theme === mode) {
         /**
-         * Ionic has many existing tests that existed prior to
-         * the introduction of palette testing. To maintain backwards
-         * compatibility, we will not include the palette in the screenshot
-         * name if the palette is set to light.
+         * Fallback to the old screenshot naming convention
+         * when the theme and mode are the same.
          */
-        return `${fileName}-${mode}-${direction}.png`;
+        if (palette === 'light') {
+            /**
+             * Ionic has many existing tests that existed prior to
+             * the introduction of theme testing. To maintain backwards
+             * compatibility, we will not include the theme in the screenshot
+             * name if the theme is set to light.
+             */
+            return `${fileName}-${theme}-${direction}.png`;
+        }
+        return `${fileName}-${theme}-${direction}-${palette}.png`;
     }
-    return `${fileName}-${mode}-${direction}-${palette}.png`;
+    return `${fileName}-${theme}-${mode}-${direction}-${palette}.png`;
 };
 /**
  * Given a config generate an array of test variants.
  */
 export const configs = (testConfig = DEFAULT_TEST_CONFIG_OPTION) => {
     var _a;
-    const { modes, directions } = testConfig;
+    const { modes, themes, directions } = testConfig;
     const configs = [];
     /**
      * If certain options are not provided,
      * fall back to the defaults.
      */
-    const processedMode = modes !== null && modes !== void 0 ? modes : DEFAULT_MODES;
+    const processedModes = modes !== null && modes !== void 0 ? modes : DEFAULT_MODES;
+    const processedTheme = themes !== null && themes !== void 0 ? themes : DEFAULT_THEMES;
     const processedDirection = directions !== null && directions !== void 0 ? directions : DEFAULT_DIRECTIONS;
     const processedPalette = (_a = testConfig.palettes) !== null && _a !== void 0 ? _a : DEFAULT_PALETTES;
-    processedMode.forEach((mode) => {
-        processedDirection.forEach((direction) => {
-            processedPalette.forEach((palette) => {
-                configs.push({ mode, direction, palette });
+    processedModes.forEach((mode) => {
+        processedTheme.forEach((theme) => {
+            if (!isModeValidForTheme(mode, theme)) {
+                return;
+            }
+            processedDirection.forEach((direction) => {
+                processedPalette.forEach((palette) => {
+                    configs.push({ theme, direction, palette, mode });
+                });
             });
         });
     });
@@ -67,10 +88,12 @@ export const configs = (testConfig = DEFAULT_TEST_CONFIG_OPTION) => {
     });
 };
 const DEFAULT_MODES = ['ios', 'md'];
+const DEFAULT_THEMES = ['ios', 'md'];
 const DEFAULT_DIRECTIONS = ['ltr', 'rtl'];
 const DEFAULT_PALETTES = ['light'];
 const DEFAULT_TEST_CONFIG_OPTION = {
     modes: DEFAULT_MODES,
+    themes: DEFAULT_THEMES,
     directions: DEFAULT_DIRECTIONS,
     palettes: DEFAULT_PALETTES,
 };

package/dist/collection/utils/test/playwright/page/utils/goto.js

@@ -9,7 +9,7 @@
  * to be hydrated before proceeding with the test.
  */
 export const goto = async (page, url, testInfo, originalFn, options) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (options === undefined && testInfo.project.metadata.mode === undefined) {
         throw new Error(`
 A config must be passed to page.goto to use a generator test:
@@ -21,13 +21,16 @@ configs().forEach(({ config, title }) => {
 });`);
     }
     let mode;
+    let theme;
     let direction;
     if (options == undefined) {
         mode = testInfo.project.metadata.mode;
+        theme = testInfo.project.metadata.theme;
         direction = testInfo.project.metadata.rtl ? 'rtl' : 'ltr';
     }
     else {
         mode = options.mode;
+        theme = options.theme;
         direction = options.direction;
     }
     const rtlString = direction === 'rtl' ? 'true' : undefined;
@@ -39,12 +42,14 @@ configs().forEach(({ config, title }) => {
      */
     const urlToParams = new URLSearchParams(paramsString);
     const formattedMode = (_a = urlToParams.get('ionic:mode')) !== null && _a !== void 0 ? _a : mode;
-    const formattedRtl = (_b = urlToParams.get('rtl')) !== null && _b !== void 0 ? _b : rtlString;
-    const ionicTesting = (_c = urlToParams.get('ionic:_testing')) !== null && _c !== void 0 ? _c : true;
+    const formattedTheme = (_b = urlToParams.get('ionic:theme')) !== null && _b !== void 0 ? _b : theme;
+    const formattedRtl = (_c = urlToParams.get('rtl')) !== null && _c !== void 0 ? _c : rtlString;
+    const ionicTesting = (_d = urlToParams.get('ionic:_testing')) !== null && _d !== void 0 ? _d : true;
     /**
      * Pass through other custom query params
      */
     urlToParams.delete('ionic:mode');
+    urlToParams.delete('ionic:theme');
     urlToParams.delete('rtl');
     urlToParams.delete('ionic:_testing');
     /**
@@ -54,11 +59,15 @@ configs().forEach(({ config, title }) => {
      */
     const remainingQueryParams = decodeURIComponent(urlToParams.toString());
     const remainingQueryParamsString = remainingQueryParams == '' ? '' : `&${remainingQueryParams}`;
-    const formattedUrl = `${splitUrl[0]}?ionic:_testing=${ionicTesting}&ionic:mode=${formattedMode}&rtl=${formattedRtl}${remainingQueryParamsString}`;
+    const formattedUrl = `${splitUrl[0]}?ionic:_testing=${ionicTesting}&ionic:mode=${formattedMode}&ionic:theme=${formattedTheme}&rtl=${formattedRtl}${remainingQueryParamsString}`;
     testInfo.annotations.push({
         type: 'mode',
         description: formattedMode,
     });
+    testInfo.annotations.push({
+        type: 'theme',
+        description: formattedTheme,
+    });
     testInfo.annotations.push({
         type: 'direction',
         description: formattedRtl === 'true' ? 'rtl' : 'ltr',

package/dist/collection/utils/test/playwright/page/utils/set-content.js

@@ -18,15 +18,18 @@ export const setContent = async (page, html, testInfo, options) => {
     }
     let mode;
     let direction;
+    let theme;
     let palette;
     if (options == undefined) {
         mode = testInfo.project.metadata.mode;
         direction = testInfo.project.metadata.rtl ? 'rtl' : 'ltr';
+        theme = testInfo.project.metadata.theme;
         palette = testInfo.project.metadata.palette;
     }
     else {
         mode = options.mode;
         direction = options.direction;
+        theme = options.theme;
         palette = options.palette;
     }
     const baseUrl = process.env.PLAYWRIGHT_TEST_BASE_URL;
@@ -45,7 +48,8 @@ export const setContent = async (page, html, testInfo, options) => {
         <script>
           window.Ionic = {
             config: {
-              mode: '${mode}'
+              mode: '${mode}',
+              theme: '${theme}'
             }
           }
         </script>
@@ -55,10 +59,18 @@ export const setContent = async (page, html, testInfo, options) => {
       </body>
     </html>
   `;
+    testInfo.annotations.push({
+        type: 'mode',
+        description: mode,
+    });
     testInfo.annotations.push({
         type: 'palette',
         description: palette,
     });
+    testInfo.annotations.push({
+        type: 'theme',
+        description: theme,
+    });
     if (baseUrl) {
         await page.route(baseUrl, (route) => {
             if (route.request().url() === `${baseUrl}/`) {

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

@@ -184,6 +184,7 @@ const animateBackButton = (rootAnimation, rtl, backDirection, backButtonEl, back
     const clonedBackButtonIconEl = shadow(clonedBackButtonEl).querySelector('ion-icon');
     clonedBackButtonEl.text = backButtonEl.text;
     clonedBackButtonEl.mode = backButtonEl.mode;
+    clonedBackButtonEl.theme = backButtonEl.theme;
     clonedBackButtonEl.icon = backButtonEl.icon;
     clonedBackButtonEl.color = backButtonEl.color;
     clonedBackButtonEl.disabled = backButtonEl.disabled;