@ionic/core 8.8.19-dev.11786610762.137bbb21 → 8.8.19-nightly.20260814

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

@@ -3,26 +3,8 @@
  */
 import { printIonError } from "../logging/index";
 /**
- * Sanitize an untrusted HTML string.
- *
- * Parses the string into a detached DOM, removes blocked tags, strips
- * attributes outside the narrow `domStringAllowedAttributes` list (refer
- * `sanitizeElement`), and scrubs script-scheme URLs. Returns the sanitized
- * HTML string.
- *
- * Use this when you have an HTML string from an unknown source and need to
- * render it via `innerHTML`. Use `sanitizeDOMTree` instead when you already
- * have a DOM tree and want to sanitize it in place without a string round
- * trip. The two apply the same dangerous-vector scrubbing but different
- * attribute allowlists: this path stays narrow so existing consumers
- * (toast, loading, alert message, etc.) are unaffected, while
- * `sanitizeDOMTree` uses the wider rich-content allowlist.
- *
- * @param untrustedString - The HTML string to sanitize. Pass an
- * `IonicSafeString` to bypass sanitization, or `undefined` to short-circuit.
- * @returns The sanitized HTML string, or `undefined` if the input was
- * `undefined`. Returns `''` if sanitization fails or the input contains
- * an inline `onload=` handler.
+ * Does a simple sanitization of all elements
+ * in an untrusted string
  */
 export const sanitizeDOMString = (untrustedString) => {
     try {
@@ -72,7 +54,7 @@ export const sanitizeDOMString = (untrustedString) => {
                 const childElements = getElementChildren(element);
                 /* eslint-disable-next-line */
                 for (let childIndex = 0; childIndex < childElements.length; childIndex++) {
-                    sanitizeElement(childElements[childIndex], domStringAllowedAttributes);
+                    sanitizeElement(childElements[childIndex]);
                 }
             }
         });
@@ -84,7 +66,7 @@ export const sanitizeDOMString = (untrustedString) => {
         const dfChildren = getElementChildren(documentFragment);
         /* eslint-disable-next-line */
         for (let childIndex = 0; childIndex < dfChildren.length; childIndex++) {
-            sanitizeElement(dfChildren[childIndex], domStringAllowedAttributes);
+            sanitizeElement(dfChildren[childIndex]);
         }
         // Append document fragment to div
         const fragmentDiv = document.createElement('div');
@@ -98,43 +80,13 @@ export const sanitizeDOMString = (untrustedString) => {
         return '';
     }
 };
-/**
- * Sanitize an entire trusted DOM tree in place.
- *
- * Removes blocked tags (`script`, `iframe`, etc.) from the subtree and
- * then sanitizes attributes on every remaining element using the wider
- * `richContentAllowedAttributes` allowlist (refer `sanitizeElement`).
- * Component presentational attributes (`size`, `color`, `shape`, inline
- * SVG, `aria-*`, `data-*`) are preserved; `style`, event handlers (`on*`),
- * form/navigation-hijack attributes, script-scheme URLs, and non-image
- * `data:` URLs are stripped.
- *
- * Use this when you have a DOM tree the developer controls (e.g.
- * cloned slot content from a component) and you need to render it
- * elsewhere safely.
- *
- * @param root - The root element whose subtree will be sanitized in
- * place. No-op when the sanitizer is disabled via `Ionic.config`.
- */
-export const sanitizeDOMTree = (root) => {
-    if (!isSanitizerEnabled()) {
-        return;
-    }
-    blockedTags.forEach((tag) => {
-        const matches = root.querySelectorAll(tag);
-        for (let i = matches.length - 1; i >= 0; i--) {
-            matches[i].remove();
-        }
-    });
-    sanitizeElement(root, richContentAllowedAttributes, richContentAllowedAttributePrefixes);
-};
 /**
  * Clean up current element based on allowed attributes
  * and then recursively dig down into any child elements to
  * clean those up as well
  */
 // TODO(FW-2832): type (using Element triggers other type errors as well)
-const sanitizeElement = (element, allowedAttributes, allowedAttributePrefixes = []) => {
+const sanitizeElement = (element) => {
     // IE uses childNodes, so ignore nodes that are not elements
     if (element.nodeType && element.nodeType !== 1) {
         return;
@@ -149,60 +101,29 @@ const sanitizeElement = (element, allowedAttributes, allowedAttributePrefixes =
         element.remove();
         return;
     }
-    /**
-     * Always strip `style` (CSS injection, `background:url()` beaconing, UI
-     * spoofing). It is never on the allowlist, but it is removed explicitly
-     * here because some engines (e.g. jsdom) don't enumerate the CSSOM-backed
-     * `style` attribute in `element.attributes`, which would let the loop
-     * below skip over it.
-     */
-    element.removeAttribute('style');
     for (let i = element.attributes.length - 1; i >= 0; i--) {
         const attribute = element.attributes.item(i);
         const attributeName = attribute.name;
-        const lowerName = attributeName.toLowerCase();
-        /**
-         * Remove any attribute that is not on the allowlist. This drops event
-         * handlers (`on*`), `style`, the form/navigation-hijack attributes
-         * (`formaction`, `action`, `target`), namespaced attributes like
-         * `xlink:href`, and anything else not explicitly known to be safe.
-         */
-        if (!isAttributeAllowed(lowerName, allowedAttributes, allowedAttributePrefixes)) {
+        // remove non-allowed attribs
+        if (!allowedAttributes.includes(attributeName.toLowerCase())) {
             element.removeAttribute(attributeName);
             continue;
         }
         // clean up any allowed attribs
         // that attempt to do any JS funny-business
         const attributeValue = attribute.value;
-        if (attributeValue == null) {
-            continue;
-        }
         /**
-         * Scrub dangerous schemes from the value. The value is normalized first
-         * (whitespace and ASCII control characters removed) so entity-obfuscated
-         * payloads such as `java&#9;script:`, which the parser decodes to
-         * `java\tscript:`, are still caught. Normalizing the value also covers
-         * namespaced attributes, where the previous `element[attributeName]`
-         * property reflection returned `undefined` and let them slip through.
+         * We also need to check the property value
+         * as javascript: can allow special characters
+         * such as &Tab; and still be valid (i.e. java&Tab;script)
          */
-        const normalizedValue = attributeValue.replace(controlCharactersAndWhitespace, '').toLowerCase();
-        // Script schemes are never allowed, on any attribute.
-        if (normalizedValue.includes('javascript:') || normalizedValue.includes('vbscript:')) {
-            element.removeAttribute(attributeName);
-            continue;
-        }
-        /**
-         * For URL-bearing attributes, allow `data:` URIs only for raster
-         * images. Document-bearing types (`text/html`, `image/svg+xml`,
-         * `application/*`, etc.) can carry markup or script when navigated to
-         * or rendered, so they are stripped, while safe image types are kept so
-         * inline images keep working.
-         */
-        if (urlAttributes.includes(lowerName) &&
-            normalizedValue.startsWith('data:') &&
-            !safeDataImageUri.test(normalizedValue)) {
+        const propertyValue = element[attributeName];
+        /* eslint-disable */
+        if ((attributeValue != null && attributeValue.toLowerCase().includes('javascript:')) ||
+            (propertyValue != null && propertyValue.toLowerCase().includes('javascript:'))) {
             element.removeAttribute(attributeName);
         }
+        /* eslint-enable */
     }
     /**
      * Sanitize any nested children
@@ -210,7 +131,7 @@ const sanitizeElement = (element, allowedAttributes, allowedAttributePrefixes =
     const childElements = getElementChildren(element);
     /* eslint-disable-next-line */
     for (let i = 0; i < childElements.length; i++) {
-        sanitizeElement(childElements[i], allowedAttributes, allowedAttributePrefixes);
+        sanitizeElement(childElements[i]);
     }
 };
 /**
@@ -235,185 +156,8 @@ const isSanitizerEnabled = () => {
     }
     return true;
 };
-/**
- * Mirror known custom-element DOM properties onto attributes so they
- * survive `cloneNode`. Call this on a DOM subtree before cloning it for
- * rendering elsewhere (e.g. cloning slotted option content into an
- * overlay).
- *
- * Only sets the attribute when the property holds a non-empty string
- * and the attribute isn't already present, so existing attributes
- * take precedence.
- *
- * @param root - The root element whose subtree (and itself) will be
- * inspected.
- */
-export const reflectPropertiesToAttributes = (root) => {
-    const candidates = [];
-    if (root.tagName in elementPropsToReflect) {
-        candidates.push(root);
-    }
-    for (const tagName of Object.keys(elementPropsToReflect)) {
-        candidates.push(...Array.from(root.querySelectorAll(tagName.toLowerCase())));
-    }
-    for (const el of candidates) {
-        if (!(el.tagName in elementPropsToReflect)) {
-            continue;
-        }
-        const props = elementPropsToReflect[el.tagName];
-        for (const prop of props) {
-            const value = el[prop];
-            if (typeof value === 'string' && value.length > 0 && !el.hasAttribute(prop)) {
-                el.setAttribute(prop, value);
-            }
-        }
-    }
-};
-/**
- * Attribute allowlist for `sanitizeDOMString`. Intentionally narrow: this
- * path sanitizes developer HTML strings rendered via `innerHTML` by
- * `ion-toast`, `ion-loading`, the `ion-alert` message,
- * `ion-refresher-content`, and `ion-infinite-scroll-content`, so the list
- * is kept to the minimum those have always needed. Broadening it here would
- * change sanitization output for all of those consumers, so the wider
- * rich-content allowlist below is deliberately scoped to `sanitizeDOMTree`
- * instead.
- */
-const domStringAllowedAttributes = ['class', 'id', 'href', 'src', 'name', 'slot'];
-/**
- * Attribute allowlist for `sanitizeDOMTree` (the select rich-content path).
- * Covers global HTML attributes, the Ionic component presentational props
- * that cloned rich content (e.g. `ion-select-option` markup) relies on, and
- * the inert SVG presentation attributes used by inline icons.
- *
- * `aria-*` and `data-*` are allowed separately by prefix (refer
- * `richContentAllowedAttributePrefixes`) since they are inert and not worth
- * enumerating. URL-bearing names (`href`, `src`) are allowed here, but
- * their values are still scrubbed for script schemes in `sanitizeElement`.
- *
- * Notably absent: `style`, event handlers (`on*`), and the
- * form/navigation-hijack attributes (`formaction`, `action`, `target`),
- * which are therefore stripped.
- */
-const richContentAllowedAttributes = [
-    // Global / structural
-    'class',
-    'id',
-    'slot',
-    'name',
-    'title',
-    'alt',
-    'lang',
-    'dir',
-    'role',
-    'type',
-    'value',
-    'disabled',
-    'width',
-    'height',
-    'href',
-    'src',
-    // Ionic component presentational props
-    'color',
-    'size',
-    'shape',
-    'fill',
-    'expand',
-    'mode',
-    'theme',
-    'icon',
-    'label',
-    'label-placement',
-    'justify',
-    'inset',
-    'lines',
-    'ios',
-    'md',
-    // SVG presentation attributes (compared lowercased, e.g. `viewBox`)
-    'xmlns',
-    'viewbox',
-    'preserveaspectratio',
-    'stroke',
-    'stroke-width',
-    'stroke-linecap',
-    'stroke-linejoin',
-    'stroke-opacity',
-    'stroke-dasharray',
-    'fill-rule',
-    'fill-opacity',
-    'clip-rule',
-    'd',
-    'points',
-    'cx',
-    'cy',
-    'r',
-    'rx',
-    'ry',
-    'x',
-    'y',
-    'x1',
-    'y1',
-    'x2',
-    'y2',
-    'transform',
-    'opacity',
-];
-/**
- * Attribute-name prefixes that are always safe to keep in the rich-content
- * path. `aria-*` and `data-*` attributes cannot execute script or load
- * resources, so they are allowed wholesale rather than enumerated by name.
- */
-const richContentAllowedAttributePrefixes = ['aria-', 'data-'];
-/**
- * Whether an attribute name (already lowercased) is safe to keep, by exact
- * match or by an allowed prefix.
- */
-const isAttributeAllowed = (lowerName, allowedAttributes, allowedAttributePrefixes) => {
-    if (allowedAttributes.includes(lowerName)) {
-        return true;
-    }
-    return allowedAttributePrefixes.some((prefix) => lowerName.startsWith(prefix));
-};
-/**
- * Matches ASCII control characters and whitespace (including the
- * non-breaking space). Used to normalize attribute values before matching
- * a URL scheme so entity-obfuscated payloads such as `java&#9;script:`
- * (decoded by the parser to `java\tscript:`) can't smuggle a scheme past
- * the check.
- */
-// eslint-disable-next-line no-control-regex -- matching control characters is the point
-const controlCharactersAndWhitespace = /[\u0000-\u0020\u007f-\u00a0]/g;
-/**
- * Attributes whose values are URLs. Their values are scheme-checked in
- * `sanitizeElement` (e.g. `data:` filtering) beyond the script-scheme scrub
- * applied to every attribute.
- */
-const urlAttributes = ['href', 'src'];
-/**
- * Matches a `data:` URI for a raster image type that cannot carry script.
- * `image/svg+xml` is deliberately excluded (SVG can execute script), as are
- * document types like `text/html` and `application/*`. The value is already
- * lowercased and whitespace-stripped before this is tested.
- */
-const safeDataImageUri = /^data:image\/(?:png|jpe?g|gif|webp|bmp|avif|x-icon|vnd\.microsoft\.icon)[;,]/;
-/**
- * Tags removed entirely (with their subtree) before attribute sanitization.
- * Exported so tests can assert the set without hardcoding it.
- */
-export const blockedTags = ['script', 'style', 'iframe', 'meta', 'link', 'object', 'embed', 'base'];
-/**
- * Properties on custom elements that frameworks (Vue, Angular) often
- * set as DOM properties rather than attributes. `cloneNode` only copies
- * attributes, so these values are lost when slotted content is cloned
- * into an overlay. For each known custom element, we mirror the listed
- * properties onto attributes so the cloned copy still has the data it
- * needs to render.
- *
- * Keyed by uppercased tagName so the lookup matches `Element.tagName`.
- */
-const elementPropsToReflect = {
-    'ION-ICON': ['icon', 'name', 'src', 'ios', 'md'],
-};
+const allowedAttributes = ['class', 'id', 'href', 'src', 'name', 'slot'];
+const blockedTags = ['script', 'style', 'iframe', 'meta', 'link', 'object', 'embed'];
 export class IonicSafeString {
     constructor(value) {
         this.value = value;

package/dist/collection/utils/test/playwright/drag-element.js

@@ -8,19 +8,7 @@
  *
  * See https://playwright.dev/docs/api/class-mouse#mouse-move for more information.
  */
-/**
- * Drags an element by the given number of pixels on the X and Y axes.
- *
- * @param el The element to drag.
- * @param page The E2E Page object.
- * @param dragByX The number of pixels to drag on the X axis. Negative values drag left, positive values drag right.
- * @param dragByY The number of pixels to drag on the Y axis. Negative values drag up, positive values drag down.
- * @param startXCoord The X coordinate to start the drag from. Defaults to the center of the element.
- * @param startYCoord The Y coordinate to start the drag from. Defaults to the center of the element.
- * @param releaseDrag Whether to release the drag at the end of the gesture. Defaults to `true`.
- * @param steps The number of steps to divide the drag into. More steps reduce velocity; fewer steps increase it. Use this to control whether velocity-based thresholds (e.g. full-swipe) are triggered, particularly in Safari where gesture velocity is calculated relative to animation frames. Defaults to `10`.
- */
-export const dragElementBy = async (el, page, dragByX = 0, dragByY = 0, startXCoord, startYCoord, releaseDrag = true, steps) => {
+export const dragElementBy = async (el, page, dragByX = 0, dragByY = 0, startXCoord, startYCoord, releaseDrag = true) => {
     var _a;
     const boundingBox = await el.boundingBox();
     if (!boundingBox) {
@@ -46,18 +34,17 @@ export const dragElementBy = async (el, page, dragByX = 0, dragByY = 0, startXCo
         await page.evaluate(() => { var _a; return (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges(); });
     }
     // Drag the element.
-    await moveElement(page, startX, startY, dragByX, dragByY, steps);
+    await moveElement(page, startX, startY, dragByX, dragByY);
     if (releaseDrag) {
         await page.mouse.up();
     }
 };
 /**
  * Drags an element by the given amount of pixels on the Y axis.
- *
  * @param el The element to drag.
  * @param page The E2E Page object.
- * @param dragByY The number of pixels to drag on the Y axis.
- * @param startYCoord The Y coordinate to start the drag from. Defaults to the center of the element.
+ * @param dragByY The amount of pixels to drag the element by.
+ * @param startYCoord The Y coordinate to start the drag gesture at. Defaults to the center of the element.
  */
 export const dragElementByYAxis = async (el, page, dragByY, startYCoord) => {
     const boundingBox = await el.boundingBox();
@@ -99,7 +86,8 @@ const validateDragByY = (startY, dragByY, viewportHeight) => {
         throw new Error(`The element is being dragged past the top of the viewport. Update the dragByY value to prevent going out of bounds. A recommended value is ${recommendedDragByY}.`);
     }
 };
-const moveElement = async (page, startX, startY, dragByX = 0, dragByY = 0, steps = 10) => {
+const moveElement = async (page, startX, startY, dragByX = 0, dragByY = 0) => {
+    const steps = 10;
     const browser = page.context().browser().browserType().name();
     const viewport = page.viewportSize();
     if (viewport === null) {
@@ -114,21 +102,10 @@ const moveElement = async (page, startX, startY, dragByX = 0, dragByY = 0, steps
         const middleX = startX + (endX - startX) * (i / steps);
         const middleY = startY + (endY - startY) * (i / steps);
         await page.mouse.move(middleX, middleY);
-        /**
-         * In Safari, gesture velocity is calculated relative to animation
-         * frames, causing velocity to accumulate faster than in other
-         * browsers. Without waiting for a repaint, consecutive `mouse.move`
-         * events arrive with ~0ms time delta and velocity never accumulates,
-         * causing gesture
-         * detection to fail.
-         */
+        // Safari needs to wait for a repaint to occur before moving the mouse again.
         if (browser === 'webkit' && i % 2 === 0) {
-            /**
-             * Repainting every 2 steps is enough to keep the drag gesture
-             * smooth. Repainting on every step makes the test slow, and
-             * repainting every 4+ steps means Safari does not see enough
-             * frames to track the gesture reliably.
-             */
+            // Repainting every 2 steps is enough to keep the drag gesture smooth.
+            // Anything past 4 steps will cause the drag gesture to be flaky.
             await page.evaluate(() => new Promise(requestAnimationFrame));
         }
     }

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

@@ -8,56 +8,34 @@
  * each test title is unique.
  */
 const generateTitle = (title, config) => {
-    const { direction, palette, mode, theme } = config;
-    /**
-     * The iOS theme can only be used with the iOS mode,
-     * and the MD theme can only be used with the MD mode.
-     *
-     * This logic enables the fallback behavior for existing tests,
-     * where we only tested against a mode, which accounted for both
-     * the theme and mode.
-     */
-    if (theme === 'ios' || theme === 'md') {
-        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} - ${mode}/${direction}`;
-        }
-        return `${title} - ${mode}/${direction}/${palette}`;
+    const { mode, direction, palette } = config;
+    if (palette === 'light') {
+        /**
+         * 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.
+         */
+        return `${title} - ${mode}/${direction}`;
     }
-    return `${title} - ${theme}/${mode}/${direction}/${palette}`;
+    return `${title} - ${mode}/${direction}/${palette}`;
 };
 /**
  * Generates a unique filename based on a base filename
  * and a test config.
  */
 const generateScreenshotName = (fileName, config) => {
-    const { direction, palette, mode, theme } = config;
-    /**
-     * The iOS theme can only be used with the iOS mode,
-     * and the MD theme can only be used with the MD mode.
-     *
-     * This logic enables the fallback behavior for existing tests,
-     * where we only tested against a mode, which accounted for both
-     * the theme and mode.
-     */
-    if (theme === 'ios' || theme === 'md') {
-        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}-${mode}-${direction}.png`;
-        }
-        return `${fileName}-${mode}-${direction}-${palette}.png`;
+    const { mode, direction, palette } = config;
+    if (palette === 'light') {
+        /**
+         * 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.
+         */
+        return `${fileName}-${mode}-${direction}.png`;
     }
-    return `${fileName}-${theme}-${mode}-${direction}-${palette}.png`;
+    return `${fileName}-${mode}-${direction}-${palette}.png`;
 };
 /**
  * Given a config generate an array of test variants.
@@ -70,16 +48,13 @@ export const configs = (testConfig = DEFAULT_TEST_CONFIG_OPTION) => {
      * If certain options are not provided,
      * fall back to the defaults.
      */
-    const processedModes = modes !== null && modes !== void 0 ? modes : DEFAULT_MODES;
+    const processedMode = modes !== null && modes !== void 0 ? modes : DEFAULT_MODES;
     const processedDirection = directions !== null && directions !== void 0 ? directions : DEFAULT_DIRECTIONS;
     const processedPalette = (_a = testConfig.palettes) !== null && _a !== void 0 ? _a : DEFAULT_PALETTES;
-    processedModes.forEach((mode) => {
-        const [themeOrCombinedMode, modeName] = mode.split('-');
-        const parsedTheme = themeOrCombinedMode;
-        const parsedMode = modeName !== null && modeName !== void 0 ? modeName : themeOrCombinedMode;
+    processedMode.forEach((mode) => {
         processedDirection.forEach((direction) => {
             processedPalette.forEach((palette) => {
-                configs.push({ direction, palette, mode: parsedMode, theme: parsedTheme });
+                configs.push({ mode, direction, palette });
             });
         });
     });

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, _d, _e;
+    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,18 +21,15 @@ configs().forEach(({ config, title }) => {
 });`);
     }
     let mode;
-    let theme;
     let direction;
     let palette;
     if (options == undefined) {
         mode = testInfo.project.metadata.mode;
-        theme = testInfo.project.metadata.theme;
         direction = testInfo.project.metadata.rtl ? 'rtl' : 'ltr';
         palette = testInfo.project.metadata.palette;
     }
     else {
         mode = options.mode;
-        theme = options.theme;
         direction = options.direction;
         palette = options.palette;
     }
@@ -45,15 +42,13 @@ configs().forEach(({ config, title }) => {
      */
     const urlToParams = new URLSearchParams(paramsString);
     const formattedMode = (_a = urlToParams.get('ionic:mode')) !== null && _a !== void 0 ? _a : mode;
-    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 formattedPalette = (_d = urlToParams.get('palette')) !== null && _d !== void 0 ? _d : palette;
-    const ionicTesting = (_e = urlToParams.get('ionic:_testing')) !== null && _e !== void 0 ? _e : true;
+    const formattedRtl = (_b = urlToParams.get('rtl')) !== null && _b !== void 0 ? _b : rtlString;
+    const formattedPalette = (_c = urlToParams.get('palette')) !== null && _c !== void 0 ? _c : palette;
+    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('palette');
     urlToParams.delete('ionic:_testing');
@@ -64,15 +59,11 @@ configs().forEach(({ config, title }) => {
      */
     const remainingQueryParams = decodeURIComponent(urlToParams.toString());
     const remainingQueryParamsString = remainingQueryParams == '' ? '' : `&${remainingQueryParams}`;
-    const formattedUrl = `${splitUrl[0]}?ionic:_testing=${ionicTesting}&ionic:mode=${formattedMode}&ionic:theme=${formattedTheme}&rtl=${formattedRtl}&palette=${formattedPalette}${remainingQueryParamsString}`;
+    const formattedUrl = `${splitUrl[0]}?ionic:_testing=${ionicTesting}&ionic:mode=${formattedMode}&rtl=${formattedRtl}&palette=${formattedPalette}${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,43 +18,29 @@ 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;
     // The Ionic bundle is included locally by default unless the test
     // config passes in the importIonicFromCDN option. This is useful
     // when testing with the CDN version of Ionic.
-    let ionicCSSImports = theme === 'ionic'
-        ? `
-    <link href="${baseUrl}/css/ionic/bundle.ionic.css" rel="stylesheet" />
-    <link href="${baseUrl}/css/utils.bundle.css" rel="stylesheet" />
-  `
-        : `
+    let ionicCSSImports = `
     <link href="${baseUrl}/css/ionic.bundle.css" rel="stylesheet" />
   `;
     let ionicJSImports = `
     <script type="module" src="${baseUrl}/dist/ionic/ionic.esm.js"></script>
   `;
     if (options === null || options === void 0 ? void 0 : options.importIonicFromCDN) {
-        ionicCSSImports =
-            theme === 'ionic'
-                ? `
-      <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@ionic/core/css/ionic/bundle.ionic.css" />
-      <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@ionic/core/css/utils.bundle.css" />
-    `
-                : `
+        ionicCSSImports = `
       <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@ionic/core/css/ionic.bundle.css" />
     `;
         ionicJSImports = `
@@ -77,8 +63,7 @@ export const setContent = async (page, html, testInfo, options) => {
         <script>
           window.Ionic = {
             config: {
-              mode: '${mode}',
-              theme: '${theme}'
+              mode: '${mode}'
             }
           }
         </script>
@@ -88,18 +73,10 @@ 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}/`) {