@ionic/core 8.8.18 → 8.8.19-dev.11786730389.1a1927bf

package/dist/collection/components/select/select.js

@@ -2,14 +2,17 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { Build, Host, h, forceUpdate } from "@stencil/core";
+import { ENABLE_HTML_CONTENT_DEFAULT } from "../../utils/config";
 import { compareOptions, createNotchController, isOptionSelected, checkInvalidState } from "../../utils/forms/index";
 import { focusVisibleElement, renderHiddenInput, inheritAttributes } from "../../utils/helpers";
 import { printIonWarning } from "../../utils/logging/index";
 import { actionSheetController, alertController, popoverController, modalController } from "../../utils/overlays";
 import { isRTL } from "../../utils/rtl/index";
+import { reflectPropertiesToAttributes, sanitizeDOMTree } from "../../utils/sanitization/index";
 import { createColorClasses, hostContext } from "../../utils/theme";
 import { watchForOptions } from "../../utils/watch-options";
 import { caretDownSharp, chevronExpand } from "ionicons/icons";
+import { config } from "../../global/config";
 import { getIonMode } from "../../global/ionic-global";
 // TODO(FW-2832): types
 /**
@@ -32,139 +35,225 @@ import { getIonMode } from "../../global/ionic-global";
  * @part inner - The inner element of the wrapper that manages the slots, selected values or placeholder, and toggle icons.
  */
 export class Select {
-    constructor() {
-        this.inputId = `ion-sel-${selectIds++}`;
-        this.helperTextId = `${this.inputId}-helper-text`;
-        this.errorTextId = `${this.inputId}-error-text`;
-        this.inheritedAttributes = {};
-        this.isExpanded = false;
-        /**
-         * The `hasFocus` state ensures the focus class is
-         * added regardless of how the element is focused.
-         * The `ion-focused` class only applies when focused
-         * via tabbing, not by clicking.
-         * The `has-focus` logic was added to ensure the class
-         * is applied in both cases.
-         */
-        this.hasFocus = false;
-        /**
-         * Track validation state for proper aria-live announcements.
-         */
-        this.isInvalid = false;
-        /**
-         * The text to display on the cancel button.
-         */
-        this.cancelText = 'Cancel';
-        /**
-         * If `true`, the user cannot interact with the select.
-         */
-        this.disabled = false;
-        /**
-         * The interface the select should use: `action-sheet`, `popover`, `alert`, or `modal`.
-         */
-        this.interface = 'alert';
-        /**
-         * Any additional options that the `alert`, `action-sheet` or `popover` interface
-         * can take. See the [ion-alert docs](./alert), the
-         * [ion-action-sheet docs](./action-sheet), the
-         * [ion-popover docs](./popover), and the [ion-modal docs](./modal) for the
-         * create options for each interface.
-         *
-         * Note: `interfaceOptions` will not override `inputs` or `buttons` with the `alert` interface.
-         */
-        this.interfaceOptions = {};
-        /**
-         * Where to place the label relative to the select.
-         * `"start"`: The label will appear to the left of the select in LTR and to the right in RTL.
-         * `"end"`: The label will appear to the right of the select in LTR and to the left in RTL.
-         * `"floating"`: The label will appear smaller and above the select when the select is focused or it has a value. Otherwise it will appear on top of the select.
-         * `"stacked"`: The label will appear smaller and above the select regardless even when the select is blurred or has no value.
-         * `"fixed"`: The label has the same behavior as `"start"` except it also has a fixed width. Long text will be truncated with ellipses ("...").
-         * When using `"floating"` or `"stacked"` we recommend initializing the select with either a `value` or a `placeholder`.
-         */
-        this.labelPlacement = 'start';
-        /**
-         * If `true`, the select can accept multiple values.
-         */
-        this.multiple = false;
-        /**
-         * The name of the control, which is submitted with the form data.
-         */
-        this.name = this.inputId;
-        /**
-         * The text to display on the ok button.
-         */
-        this.okText = 'OK';
-        /**
-         * If true, screen readers will announce it as a required field. This property
-         * works only for accessibility purposes, it will not prevent the form from
-         * submitting if the value is invalid.
-         */
-        this.required = false;
-        this.onClick = (ev) => {
-            const target = ev.target;
-            const closestSlot = target.closest('[slot="start"], [slot="end"]');
-            if (target === this.el || closestSlot === null) {
-                this.setFocus();
-                this.open(ev);
-            }
-            else {
-                /**
-                 * Prevent clicks to the start/end slots from opening the select.
-                 * We ensure the target isn't this element in case the select is slotted
-                 * in, for example, an item. This would prevent the select from ever
-                 * being opened since the element itself has slot="start"/"end".
-                 *
-                 * Clicking a slotted element also causes a click
-                 * on the <label> element (since it wraps the slots).
-                 * Clicking <label> dispatches another click event on
-                 * the native form control that then bubbles up to this
-                 * listener. This additional event targets the host
-                 * element, so the select overlay is opened.
-                 *
-                 * When the slotted elements are clicked (and therefore
-                 * the ancestor <label> element) we want to prevent the label
-                 * from dispatching another click event.
-                 *
-                 * Do not call stopPropagation() because this will cause
-                 * click handlers on the slotted elements to never fire in React.
-                 * When developers do onClick in React a native "click" listener
-                 * is added on the root element, not the slotted element. When that
-                 * native click listener fires, React then dispatches the synthetic
-                 * click event on the slotted element. However, if stopPropagation
-                 * is called then the native click event will never bubble up
-                 * to the root element.
-                 */
-                ev.preventDefault();
-            }
-        };
-        this.onFocus = () => {
-            this.hasFocus = true;
-            this.ionFocus.emit();
-        };
-        this.onBlur = () => {
-            this.hasFocus = false;
-            this.ionBlur.emit();
-        };
-        /**
-         * Stops propagation when the label is clicked,
-         * otherwise, two clicks will be triggered.
-         */
-        this.onLabelClick = (ev) => {
-            // Only stop propagation if the click was directly on the label
-            // and not on the input or other child elements
-            if (ev.target === ev.currentTarget) {
-                ev.stopPropagation();
-            }
-        };
-    }
+    inputId = `ion-sel-${selectIds++}`;
+    helperTextId = `${this.inputId}-helper-text`;
+    errorTextId = `${this.inputId}-error-text`;
+    overlay;
+    focusEl;
+    mutationO;
+    inheritedAttributes = {};
+    nativeWrapperEl;
+    notchSpacerEl;
+    validationObserver;
+    notchController;
+    customHTMLEnabled = config.get('innerHTMLTemplatesEnabled', ENABLE_HTML_CONTENT_DEFAULT);
+    el;
+    isExpanded = false;
+    /**
+     * The `hasFocus` state ensures the focus class is
+     * added regardless of how the element is focused.
+     * The `ion-focused` class only applies when focused
+     * via tabbing, not by clicking.
+     * The `has-focus` logic was added to ensure the class
+     * is applied in both cases.
+     */
+    hasFocus = false;
+    /**
+     * Track validation state for proper aria-live announcements.
+     */
+    isInvalid = false;
+    hintTextId;
+    /**
+     * The text to display on the cancel button.
+     */
+    cancelText = 'Cancel';
+    /**
+     * The color to use from your application's color palette.
+     * Default options are: `"primary"`, `"secondary"`, `"tertiary"`, `"success"`, `"warning"`, `"danger"`, `"light"`, `"medium"`, and `"dark"`.
+     * For more information on colors, see [theming](/docs/theming/basics).
+     *
+     * This property is only available when using the modern select syntax.
+     */
+    color;
+    /**
+     * This property allows developers to specify a custom function or property
+     * name for comparing objects when determining the selected option in the
+     * ion-select. When not specified, the default behavior will use strict
+     * equality (===) for comparison.
+     */
+    compareWith;
+    /**
+     * If `true`, the user cannot interact with the select.
+     */
+    disabled = false;
+    /**
+     * The fill for the item. If `"solid"` the item will have a background. If
+     * `"outline"` the item will be transparent with a border. Only available in `md` mode.
+     */
+    fill;
+    /**
+     * Text that is placed under the select and displayed when an error is detected.
+     */
+    errorText;
+    /**
+     * Text that is placed under the select and displayed when no error is detected.
+     */
+    helperText;
+    /**
+     * The interface the select should use: `action-sheet`, `popover`, `alert`, or `modal`.
+     */
+    interface = 'alert';
+    /**
+     * Any additional options that the `alert`, `action-sheet` or `popover` interface
+     * can take. See the [ion-alert docs](./alert), the
+     * [ion-action-sheet docs](./action-sheet), the
+     * [ion-popover docs](./popover), and the [ion-modal docs](./modal) for the
+     * create options for each interface.
+     *
+     * Note: `interfaceOptions` will not override `inputs` or `buttons` with the `alert` interface.
+     */
+    interfaceOptions = {};
+    /**
+     * How to pack the label and select within a line.
+     * `justify` does not apply when the label and select
+     * are on different lines when `labelPlacement` is set to
+     * `"floating"` or `"stacked"`.
+     * `"start"`: The label and select will appear on the left in LTR and
+     * on the right in RTL.
+     * `"end"`: The label and select will appear on the right in LTR and
+     * on the left in RTL.
+     * `"space-between"`: The label and select will appear on opposite
+     * ends of the line with space between the two elements.
+     */
+    justify;
+    /**
+     * The visible label associated with the select.
+     *
+     * Use this if you need to render a plaintext label.
+     *
+     * The `label` property will take priority over the `label` slot if both are used.
+     */
+    label;
+    /**
+     * Where to place the label relative to the select.
+     * `"start"`: The label will appear to the left of the select in LTR and to the right in RTL.
+     * `"end"`: The label will appear to the right of the select in LTR and to the left in RTL.
+     * `"floating"`: The label will appear smaller and above the select when the select is focused or it has a value. Otherwise it will appear on top of the select.
+     * `"stacked"`: The label will appear smaller and above the select regardless even when the select is blurred or has no value.
+     * `"fixed"`: The label has the same behavior as `"start"` except it also has a fixed width. Long text will be truncated with ellipses ("...").
+     * When using `"floating"` or `"stacked"` we recommend initializing the select with either a `value` or a `placeholder`.
+     */
+    labelPlacement = 'start';
+    /**
+     * If `true`, the select can accept multiple values.
+     */
+    multiple = false;
+    /**
+     * The name of the control, which is submitted with the form data.
+     */
+    name = this.inputId;
+    /**
+     * The text to display on the ok button.
+     */
+    okText = 'OK';
+    /**
+     * The text to display when the select is empty.
+     */
+    placeholder;
+    /**
+     * The text to display instead of the selected option's value.
+     */
+    selectedText;
+    /**
+     * The toggle icon to use. Defaults to `chevronExpand` for `ios` mode,
+     * or `caretDownSharp` for `md` mode.
+     */
+    toggleIcon;
+    /**
+     * The toggle icon to show when the select is open. If defined, the icon
+     * rotation behavior in `md` mode will be disabled. If undefined, `toggleIcon`
+     * will be used for when the select is both open and closed.
+     */
+    expandedIcon;
+    /**
+     * The shape of the select. If "round" it will have an increased border radius.
+     */
+    shape;
+    /**
+     * The value of the select.
+     */
+    value;
+    /**
+     * If true, screen readers will announce it as a required field. This property
+     * works only for accessibility purposes, it will not prevent the form from
+     * submitting if the value is invalid.
+     */
+    required = false;
+    /**
+     * Emitted when the value has changed.
+     *
+     * This event will not emit when programmatically setting the `value` property.
+     */
+    ionChange;
+    /**
+     * Emitted when the selection is cancelled.
+     */
+    ionCancel;
+    /**
+     * Emitted when the overlay is dismissed.
+     */
+    ionDismiss;
+    /**
+     * Emitted when the select has focus.
+     */
+    ionFocus;
+    /**
+     * Emitted when the select loses focus.
+     */
+    ionBlur;
+    /**
+     * Emitted when the styles change.
+     * @internal
+     */
+    ionStyle;
     styleChanged() {
         this.emitStyle();
     }
     setValue(value) {
+        if (this.isValueEqual(this.value, value)) {
+            return;
+        }
         this.value = value;
         this.ionChange.emit({ value });
     }
+    isValueEqual(currentValue, newValue) {
+        if (this.multiple) {
+            const currentArr = Array.isArray(currentValue) ? currentValue : [];
+            const newArr = Array.isArray(newValue) ? newValue : [];
+            if (currentArr.length !== newArr.length) {
+                return false;
+            }
+            // Multiset compare: each new value must match a distinct current value.
+            // A plain `every(isOptionSelected)` would accept ['a','a'] as equal to
+            // ['a','b'] when both 'a' and 'b' map to options whose values overlap.
+            const remaining = currentArr.slice();
+            return newArr.every((val) => {
+                const idx = remaining.findIndex((c) => compareOptions(c, val, this.compareWith));
+                if (idx === -1) {
+                    return false;
+                }
+                remaining.splice(idx, 1);
+                return true;
+            });
+        }
+        if (currentValue == null && newValue == null) {
+            return true;
+        }
+        if (currentValue == null || newValue == null) {
+            return false;
+        }
+        return compareOptions(currentValue, newValue, this.compareWith);
+    }
     async connectedCallback() {
         const { el } = this;
         this.notchController = createNotchController(el, () => this.notchSpacerEl, () => this.labelSlot);
@@ -399,10 +488,11 @@ export class Select {
                 .join(' ');
             const optClass = `${OPTION_CLASS} ${copyClasses}`;
             const isSelected = isOptionSelected(selectValue, value, this.compareWith);
+            const { content, startContent, endContent } = extractOptionContent(option, this.customHTMLEnabled);
             return {
-                role: isSelected ? 'selected' : '',
-                text: option.textContent,
+                text: content ?? '',
                 cssClass: optClass,
+                disabled: option.disabled,
                 handler: () => {
                     this.setValue(value);
                 },
@@ -410,6 +500,9 @@ export class Select {
                     'aria-checked': isSelected ? 'true' : 'false',
                     role: 'radio',
                 },
+                startContent,
+                endContent,
+                description: option.description,
             };
         });
         // Add "cancel" button
@@ -430,13 +523,19 @@ export class Select {
                 .filter((cls) => cls !== 'hydrated')
                 .join(' ');
             const optClass = `${OPTION_CLASS} ${copyClasses}`;
+            const { content, startContent, endContent } = extractOptionContent(option, this.customHTMLEnabled);
             return {
                 type: inputType,
                 cssClass: optClass,
-                label: option.textContent || '',
+                label: content ?? '',
                 value,
                 checked: isOptionSelected(selectValue, value, this.compareWith),
                 disabled: option.disabled,
+                startContent,
+                endContent,
+                description: option.description,
+                labelPlacement: option.labelPlacement,
+                justify: option.justify,
             };
         });
         return alertInputs;
@@ -449,8 +548,9 @@ export class Select {
                 .filter((cls) => cls !== 'hydrated')
                 .join(' ');
             const optClass = `${OPTION_CLASS} ${copyClasses}`;
+            const { content, startContent, endContent } = extractOptionContent(option, this.customHTMLEnabled);
             return {
-                text: option.textContent || '',
+                text: content ?? '',
                 cssClass: optClass,
                 value,
                 checked: isOptionSelected(selectValue, value, this.compareWith),
@@ -461,6 +561,11 @@ export class Select {
                         this.close();
                     }
                 },
+                startContent,
+                endContent,
+                description: option.description,
+                labelPlacement: option.labelPlacement,
+                justify: option.justify,
             };
         });
         return popoverOptions;
@@ -489,28 +594,43 @@ export class Select {
              */
         }
         else {
-            event = Object.assign(Object.assign({}, ev), { detail: {
+            event = {
+                ...ev,
+                detail: {
                     ionShadowTarget: this.nativeWrapperEl,
-                } });
+                },
+            };
         }
-        const popoverOpts = Object.assign(Object.assign({ mode,
-            event, alignment: 'center', size,
-            showBackdrop }, interfaceOptions), { component: 'ion-select-popover', cssClass: ['select-popover', interfaceOptions.cssClass], componentProps: {
+        const options = this.createOverlaySelectOptions(this.childOpts, value);
+        const hasRichContent = options.some((opt) => Boolean(opt.startContent) || Boolean(opt.endContent) || Boolean(opt.description));
+        const popoverOpts = {
+            mode,
+            event,
+            alignment: 'center',
+            size,
+            showBackdrop,
+            ...interfaceOptions,
+            component: 'ion-select-popover',
+            cssClass: [
+                'select-popover',
+                hasRichContent ? 'select-popover-rich-content' : undefined,
+                interfaceOptions.cssClass,
+            ],
+            componentProps: {
                 header: interfaceOptions.header,
                 subHeader: interfaceOptions.subHeader,
                 message: interfaceOptions.message,
                 multiple,
                 value,
-                options: this.createOverlaySelectOptions(this.childOpts, value),
-            } });
+                options,
+            },
+        };
         /**
          * Workaround for Stencil to autodefine
          * ion-select-popover and ion-popover when
          * using Custom Elements build.
          */
-        // eslint-disable-next-line
         if (false) {
-            // eslint-disable-next-line
             // @ts-ignore
             document.createElement('ion-select-popover');
             document.createElement('ion-popover');
@@ -520,15 +640,18 @@ export class Select {
     async openActionSheet() {
         const mode = getIonMode(this);
         const interfaceOptions = this.interfaceOptions;
-        const actionSheetOpts = Object.assign(Object.assign({ mode }, interfaceOptions), { buttons: this.createActionSheetButtons(this.childOpts, this.value), cssClass: ['select-action-sheet', interfaceOptions.cssClass] });
+        const actionSheetOpts = {
+            mode,
+            ...interfaceOptions,
+            buttons: this.createActionSheetButtons(this.childOpts, this.value),
+            cssClass: ['select-action-sheet', interfaceOptions.cssClass],
+        };
         /**
          * Workaround for Stencil to autodefine
          * ion-action-sheet when
          * using Custom Elements build.
          */
-        // eslint-disable-next-line
         if (false) {
-            // eslint-disable-next-line
             // @ts-ignore
             document.createElement('ion-action-sheet');
         }
@@ -538,7 +661,12 @@ export class Select {
         const interfaceOptions = this.interfaceOptions;
         const inputType = this.multiple ? 'checkbox' : 'radio';
         const mode = getIonMode(this);
-        const alertOpts = Object.assign(Object.assign({ mode }, interfaceOptions), { header: interfaceOptions.header ? interfaceOptions.header : this.labelText, inputs: this.createAlertInputs(this.childOpts, inputType, this.value), buttons: [
+        const alertOpts = {
+            mode,
+            ...interfaceOptions,
+            header: interfaceOptions.header ? interfaceOptions.header : this.labelText,
+            inputs: this.createAlertInputs(this.childOpts, inputType, this.value),
+            buttons: [
                 {
                     text: this.cancelText,
                     role: 'cancel',
@@ -552,19 +680,19 @@ export class Select {
                         this.setValue(selectedValues);
                     },
                 },
-            ], cssClass: [
+            ],
+            cssClass: [
                 'select-alert',
                 interfaceOptions.cssClass,
                 this.multiple ? 'multiple-select-alert' : 'single-select-alert',
-            ] });
+            ],
+        };
         /**
          * Workaround for Stencil to autodefine
          * ion-alert when
          * using Custom Elements build.
          */
-        // eslint-disable-next-line
         if (false) {
-            // eslint-disable-next-line
             // @ts-ignore
             document.createElement('ion-alert');
         }
@@ -573,21 +701,25 @@ export class Select {
     openModal() {
         const { multiple, value, interfaceOptions } = this;
         const mode = getIonMode(this);
-        const modalOpts = Object.assign(Object.assign({}, interfaceOptions), { mode, cssClass: ['select-modal', interfaceOptions.cssClass], component: 'ion-select-modal', componentProps: {
+        const modalOpts = {
+            ...interfaceOptions,
+            mode,
+            cssClass: ['select-modal', interfaceOptions.cssClass],
+            component: 'ion-select-modal',
+            componentProps: {
                 header: interfaceOptions.header,
                 cancelText: this.cancelText,
                 multiple,
                 value,
                 options: this.createOverlaySelectOptions(this.childOpts, value),
-            } });
+            },
+        };
         /**
          * Workaround for Stencil to autodefine
          * ion-select-modal and ion-modal when
          * using Custom Elements build.
          */
-        // eslint-disable-next-line
         if (false) {
-            // eslint-disable-next-line
             // @ts-ignore
             document.createElement('ion-select-modal');
             document.createElement('ion-modal');
@@ -628,12 +760,18 @@ export class Select {
         }
         return;
     }
-    getText() {
+    /**
+     * Returns the text to display in the select based on the selected value.
+     *
+     * @param useHTML If `true`, the returned text will include any custom HTML content from the selected option. If `false`, the returned text will be plain text without any HTML. Defaults to `false`.
+     * @returns The text to display in the select, either with or without HTML based on the `useHTML` parameter.
+     */
+    getText(useHTML = false) {
         const selectedText = this.selectedText;
         if (selectedText != null && selectedText !== '') {
             return selectedText;
         }
-        return generateText(this.childOpts, this.value, this.compareWith);
+        return generateText(this.childOpts, this.value, this.compareWith, useHTML);
     }
     setFocus() {
         if (this.focusEl) {
@@ -647,6 +785,51 @@ export class Select {
         };
         this.ionStyle.emit(style);
     }
+    onClick = (ev) => {
+        const target = ev.target;
+        const closestSlot = target.closest('[slot="start"], [slot="end"]');
+        if (target === this.el || closestSlot === null) {
+            this.setFocus();
+            this.open(ev);
+        }
+        else {
+            /**
+             * Prevent clicks to the start/end slots from opening the select.
+             * We ensure the target isn't this element in case the select is slotted
+             * in, for example, an item. This would prevent the select from ever
+             * being opened since the element itself has slot="start"/"end".
+             *
+             * Clicking a slotted element also causes a click
+             * on the <label> element (since it wraps the slots).
+             * Clicking <label> dispatches another click event on
+             * the native form control that then bubbles up to this
+             * listener. This additional event targets the host
+             * element, so the select overlay is opened.
+             *
+             * When the slotted elements are clicked (and therefore
+             * the ancestor <label> element) we want to prevent the label
+             * from dispatching another click event.
+             *
+             * Do not call stopPropagation() because this will cause
+             * click handlers on the slotted elements to never fire in React.
+             * When developers do onClick in React a native "click" listener
+             * is added on the root element, not the slotted element. When that
+             * native click listener fires, React then dispatches the synthetic
+             * click event on the slotted element. However, if stopPropagation
+             * is called then the native click event will never bubble up
+             * to the root element.
+             */
+            ev.preventDefault();
+        }
+    };
+    onFocus = () => {
+        this.hasFocus = true;
+        this.ionFocus.emit();
+    };
+    onBlur = () => {
+        this.hasFocus = false;
+        this.ionBlur.emit();
+    };
     renderLabel() {
         const { label } = this;
         return (h("div", { class: {
@@ -655,8 +838,7 @@ export class Select {
             }, part: "label" }, label === undefined ? h("slot", { name: "label" }) : h("div", { class: "label-text" }, label)));
     }
     componentDidRender() {
-        var _a;
-        (_a = this.notchController) === null || _a === void 0 ? void 0 : _a.calculateNotchWidth();
+        this.notchController?.calculateNotchWidth();
     }
     /**
      * Gets any content passed into the `label` slot,
@@ -674,6 +856,17 @@ export class Select {
     get hasLabel() {
         return this.label !== undefined || this.labelSlot !== null;
     }
+    /**
+     * Stops propagation when the label is clicked,
+     * otherwise, two clicks will be triggered.
+     */
+    onLabelClick = (ev) => {
+        // Only stop propagation if the click was directly on the label
+        // and not on the input or other child elements
+        if (ev.target === ev.currentTarget) {
+            ev.stopPropagation();
+        }
+    };
     /**
      * Renders the border container
      * when fill="outline".
@@ -703,6 +896,46 @@ export class Select {
          */
         return this.renderLabel();
     }
+    /**
+     * Wraps text nodes in the select text with span elements
+     * so spacing can be added between elements without
+     * changing the display to prevent losing the ellipses
+     * behavior.
+     *
+     * Only wraps when the string contains HTML elements
+     * alongside text.
+     */
+    wrapSelectTextNodes(html) {
+        const temp = document.createElement('div');
+        temp.innerHTML = html;
+        const hasElements = Array.from(temp.childNodes).some((n) => n.nodeType === Node.ELEMENT_NODE);
+        // Return the plain text
+        if (!hasElements) {
+            return html;
+        }
+        Array.from(temp.childNodes).forEach((node) => {
+            if (node.nodeType === Node.TEXT_NODE && node.textContent?.trim()) {
+                const text = node.textContent;
+                /**
+                 * Split comma separator from the text content
+                 * e.g., ", Bacon" becomes ", " text node + <span>Bacon</span>.
+                 */
+                const commaMatch = text.match(/^(,\s*)(.*)/);
+                if (commaMatch) {
+                    const commaNode = document.createTextNode(commaMatch[1]);
+                    const wrapper = document.createElement('span');
+                    wrapper.textContent = commaMatch[2];
+                    node.parentNode?.replaceChild(wrapper, node);
+                    wrapper.parentNode?.insertBefore(commaNode, wrapper);
+                    return;
+                }
+                const wrapper = document.createElement('span');
+                node.parentNode?.replaceChild(wrapper, node);
+                wrapper.appendChild(node);
+            }
+        });
+        return temp.innerHTML;
+    }
     /**
      * Renders either the placeholder
      * or the selected values based on
@@ -710,7 +943,7 @@ export class Select {
      */
     renderSelectText() {
         const { placeholder } = this;
-        const displayValue = this.getText();
+        const displayValue = this.getText(true);
         let addPlaceholderClass = false;
         let selectText = displayValue;
         if (selectText === '' && placeholder !== undefined) {
@@ -722,6 +955,10 @@ export class Select {
             'select-placeholder': addPlaceholderClass,
         };
         const textPart = addPlaceholderClass ? 'placeholder' : 'text';
+        if (this.customHTMLEnabled) {
+            const wrapped = this.wrapSelectTextNodes(selectText);
+            return h("div", { "aria-hidden": "true", class: selectTextClasses, part: textPart, innerHTML: wrapped });
+        }
         return (h("div", { "aria-hidden": "true", class: selectTextClasses, part: textPart }, selectText));
     }
     /**
@@ -737,16 +974,16 @@ export class Select {
         }
         else {
             const defaultIcon = mode === 'ios' ? chevronExpand : caretDownSharp;
-            icon = toggleIcon !== null && toggleIcon !== void 0 ? toggleIcon : defaultIcon;
+            icon = toggleIcon ?? defaultIcon;
         }
         return h("ion-icon", { class: "select-icon", part: "icon", "aria-hidden": "true", icon: icon });
     }
     get ariaLabel() {
-        var _a;
         const { placeholder, inheritedAttributes } = this;
+        // Get the plain text from the selected text
         const displayValue = this.getText();
         // The aria label should be preferred over visible text if both are specified
-        const definedLabel = (_a = inheritedAttributes['aria-label']) !== null && _a !== void 0 ? _a : this.labelText;
+        const definedLabel = inheritedAttributes['aria-label'] ?? this.labelText;
         /**
          * If developer has specified a placeholder
          * and there is nothing selected, the selectText
@@ -838,7 +1075,7 @@ export class Select {
          */
         const labelShouldFloat = labelPlacement === 'stacked' ||
             (labelPlacement === 'floating' && (hasValue || hasFocus || isExpanded || hasStartEndSlots));
-        return (h(Host, { key: 'f16327d6866ffee76e1618fcd3281590ca0fd56d', onClick: this.onClick, class: createColorClasses(this.color, {
+        return (h(Host, { key: 'e693afee7852c89be122b785230ed8fc9be5ba61', onClick: this.onClick, class: createColorClasses(this.color, {
                 [mode]: true,
                 'in-item': inItem,
                 'in-item-color': hostContext('ion-item.ion-color', el),
@@ -856,7 +1093,7 @@ export class Select {
                 [`select-justify-${justify}`]: justifyEnabled,
                 [`select-shape-${shape}`]: shape !== undefined,
                 [`select-label-placement-${labelPlacement}`]: true,
-            }) }, h("label", { key: 'db13f76b384a7a7461c1ad752108eadf9c0213be', class: "select-wrapper", id: "select-label", onClick: this.onLabelClick, part: "wrapper" }, this.renderLabelContainer(), h("div", { key: '2fb0e57bd596c0f525be79293b7da4aca55a9385', class: "select-wrapper-inner", part: "inner" }, h("slot", { key: 'cd694c36242789a89461ed3412af9891ad68411b', name: "start" }), h("div", { key: 'fdf62911be54f4ab29eb3c2eb153f082e76a8f49', class: "native-wrapper", ref: (el) => (this.nativeWrapperEl = el), part: "container" }, this.renderSelectText(), this.renderListbox()), h("slot", { key: 'a32f5c4b101d4d6ad45870f4c4446960009377f5', name: "end" }), !hasFloatingOrStackedLabel && this.renderSelectIcon()), hasFloatingOrStackedLabel && this.renderSelectIcon(), shouldRenderHighlight && h("div", { key: '61f792024a5f221ef4f28a3c249bd3a0de5edeab', class: "select-highlight" })), this.renderBottomContent()));
+            }) }, h("label", { key: 'd79647bd83cab506f01a4588f631b3982fa1c011', class: "select-wrapper", id: "select-label", onClick: this.onLabelClick, part: "wrapper" }, this.renderLabelContainer(), h("div", { key: 'fa8d78b9ea041dc9e897643f22f33f38e645ce69', class: "select-wrapper-inner", part: "inner" }, h("slot", { key: '45666226a6898a538849bd3d3b89510bf689656f', name: "start" }), h("div", { key: '59f1f08109c4cda699cb2a9f2a6bce00a7fc4301', class: "native-wrapper", ref: (el) => (this.nativeWrapperEl = el), part: "container" }, this.renderSelectText(), this.renderListbox()), h("slot", { key: '79b18fd4ca2af9528ff89c609ea20b3e727701e1', name: "end" }), !hasFloatingOrStackedLabel && this.renderSelectIcon()), hasFloatingOrStackedLabel && this.renderSelectIcon(), shouldRenderHighlight && h("div", { key: '0149f4ddb4ca1d1d2e2ca91b6cbec721d5c8aa9b', class: "select-highlight" })), this.renderBottomContent()));
     }
     static get is() { return "ion-select"; }
     static get encapsulation() { return "shadow"; }
@@ -1516,25 +1753,219 @@ const parseValue = (value) => {
     }
     return value.toString();
 };
-const generateText = (opts, value, compareWith) => {
+const generateText = (opts, value, compareWith, useHTML = false) => {
     if (value === undefined) {
         return '';
     }
     if (Array.isArray(value)) {
         return value
-            .map((v) => textForValue(opts, v, compareWith))
+            .map((v) => textForValue(opts, v, compareWith, useHTML))
             .filter((opt) => opt !== null)
             .join(', ');
     }
     else {
-        return textForValue(opts, value, compareWith) || '';
+        return textForValue(opts, value, compareWith, useHTML) || '';
     }
 };
-const textForValue = (opts, value, compareWith) => {
+/**
+ * Returns the display text for a given value from the list of options.
+ * When `useHTML` is true, returns sanitized HTML for the select text.
+ * When `useHTML` is false, returns plain text for aria-label and other
+ * text-only contexts.
+ *
+ * @param opts - The list of ion-select-option elements.
+ * @param value - The value to find the matching option for.
+ * @param compareWith - Custom comparison function or property name.
+ * @param useHTML - If true, returns HTML string. If false, returns plain text.
+ */
+const textForValue = (opts, value, compareWith, useHTML = false) => {
     const selectOpt = opts.find((opt) => {
         return compareOptions(value, getOptionValue(opt), compareWith);
     });
-    return selectOpt ? selectOpt.textContent : null;
+    const customHTMLEnabled = config.get('innerHTMLTemplatesEnabled', ENABLE_HTML_CONTENT_DEFAULT);
+    if (!selectOpt) {
+        return null;
+    }
+    // Return sanitized HTML for the select text
+    if (customHTMLEnabled && useHTML) {
+        return getOptionContent(selectOpt, undefined, true);
+    }
+    /**
+     * When custom HTML is enabled, extract only the default slot content.
+     * This ensures aria-label and other text-only contexts read only
+     * the relevant option text.
+     */
+    if (customHTMLEnabled) {
+        const content = getOptionContent(selectOpt);
+        if (typeof content === 'string') {
+            return content;
+        }
+        /**
+         * Elements were found in the default slot, extract and concatenate
+         * their text content while trimming whitespace.
+         */
+        if (content) {
+            const texts = Array.from(content.childNodes)
+                .map((n) => n.textContent?.trim())
+                .filter((t) => t);
+            return texts.join(' ') || null;
+        }
+        // Empty option
+        return null;
+    }
+    return getDefaultSlotPlainText(selectOpt);
+};
+/**
+ * Trims whitespace from all text nodes within a DOM tree.
+ * This prevents invisible layout shifts and unwanted gaps between
+ * elements when HTML content is injected via innerHTML or cloneNode,
+ * as browsers preserve whitespace (tabs, newlines, spaces) from
+ * the original source markup.
+ *
+ * @param node The root node to start trimming text nodes from.
+ */
+const trimTextNodes = (node) => {
+    node.childNodes.forEach((child) => {
+        if (child.nodeType === Node.TEXT_NODE) {
+            child.textContent = child.textContent?.trim() || '';
+        }
+        else if (child.nodeType === Node.ELEMENT_NODE) {
+            trimTextNodes(child);
+        }
+    });
+};
+/**
+ * Extracts and clones content from an `ion-select-option` element
+ * for rendering within overlay interfaces or the select text when `customHTMLEnabled` is `true`.
+ *
+ * @param option - The `ion-select-option` element to extract content from.
+ * @param slotName - Optional slot name to extract. If omitted, extracts the default slot content.
+ * @param useHTML - If `true`, the returned string will include any custom HTML content. If `false`, the returned string will be plain text without any HTML.
+ * @returns When `useHTML` is `true`, a sanitized HTML string. When `false`, a
+ * div element containing cloned child nodes. Returns `null` if no matching
+ * content is found.
+ */
+const getOptionContent = (option, slotName, useHTML = false) => {
+    let nodes;
+    if (slotName) {
+        // Named slot: get elements with matching slot attribute
+        nodes = Array.from(option.children).filter((el) => el.getAttribute('slot') === slotName);
+    }
+    else {
+        // Default slot: get nodes without a slot attribute
+        const defaultSlot = getOptionDefaultSlot(option) || [];
+        nodes = defaultSlot.filter((node) => {
+            /**
+             * Exclude whitespace-only text nodes (newline noise between
+             * markup elements). Element nodes are always kept, even when
+             * their textContent is empty (e.g. <svg>, <img>).
+             */
+            if (node.nodeType === Node.TEXT_NODE) {
+                return node.textContent?.trim().length !== 0;
+            }
+            return true;
+        });
+    }
+    if (nodes.length === 0) {
+        return null;
+    }
+    // Return plain text if no elements are found
+    if (!slotName && nodes.every((n) => n.nodeType === Node.TEXT_NODE)) {
+        return nodes.map((n) => n.textContent?.trim()).join(' ') || null;
+    }
+    /**
+     * Mirror known custom-element properties (e.g. ion-icon's `icon`)
+     * onto attributes before cloning. Frameworks like Vue set these as
+     * DOM properties, which `cloneNode` doesn't copy, so without this
+     * step the cloned overlay copy renders without the prop's value.
+     */
+    nodes.forEach((n) => {
+        if (n.nodeType === Node.ELEMENT_NODE) {
+            reflectPropertiesToAttributes(n);
+        }
+    });
+    // Clone each node into a temporary container
+    const container = document.createElement('div');
+    nodes.forEach((n) => {
+        const clone = n.cloneNode(true);
+        if (clone.nodeType === Node.TEXT_NODE) {
+            clone.textContent = clone.textContent?.trim() || '';
+        }
+        else {
+            trimTextNodes(clone);
+        }
+        container.appendChild(clone);
+    });
+    /**
+     * Sanitize the cloned DOM in place. Trusted attributes (size, color,
+     * shape, etc.) are preserved; event handlers, javascript: URLs, and
+     * blocked tags are stripped.
+     */
+    sanitizeDOMTree(container);
+    if (useHTML) {
+        return container.innerHTML.trim() || null;
+    }
+    return container;
+};
+/**
+ * Returns the child nodes that belong to the default slot of an
+ * option element, excluding any nodes that are assigned to named
+ * slots.
+ *
+ * @param option - The `ion-select-option` element to extract default-slot nodes from.
+ * @returns An array of default slot nodes, or `null` if none are found.
+ */
+const getOptionDefaultSlot = (option) => {
+    const defaultSlotNodes = Array.from(option.childNodes).filter((node) => {
+        if (node.nodeType === Node.ELEMENT_NODE) {
+            return !node.hasAttribute('slot');
+        }
+        return node.nodeType === Node.TEXT_NODE;
+    });
+    if (defaultSlotNodes.length === 0) {
+        return null;
+    }
+    return defaultSlotNodes;
+};
+/**
+ * Extracts plain text from only the default slot of an option,
+ * excluding content assigned to named slots (start/end).
+ */
+const getDefaultSlotPlainText = (option) => {
+    const texts = Array.from(option.childNodes)
+        .filter((node) => {
+        if (node.nodeType === Node.ELEMENT_NODE) {
+            return !node.hasAttribute('slot');
+        }
+        return node.nodeType === Node.TEXT_NODE;
+    })
+        .filter((node) => node.nodeType === Node.TEXT_NODE)
+        .map((n) => n.textContent?.trim())
+        .filter((t) => t);
+    return texts.join(' ');
+};
+/**
+ * Extracts the rich content from an `ion-select-option`.
+ * When `customHTMLEnabled` is `false`, only the plain text from the
+ * default slot is read and the start and end slots are skipped.
+ *
+ * @param option - The `ion-select-option` element to extract content from.
+ * @param customHTMLEnabled - Whether custom HTML rendering is enabled
+ * via the `innerHTMLTemplatesEnabled` config.
+ */
+const extractOptionContent = (option, customHTMLEnabled) => {
+    if (!customHTMLEnabled) {
+        return {
+            content: getDefaultSlotPlainText(option),
+            startContent: undefined,
+            endContent: undefined,
+        };
+    }
+    return {
+        content: getOptionContent(option),
+        startContent: getOptionContent(option, 'start') ?? undefined,
+        endContent: getOptionContent(option, 'end') ?? undefined,
+    };
 };
 let selectIds = 0;
 const OPTION_CLASS = 'select-interface-option';