voyager-ionic-core 9.0.3 → 9.0.7

package/dist/collection/components/modal/modal.js

@@ -21,8 +21,8 @@ import { mdEnterAnimation } from "./animations/md.enter";
 import { mdLeaveAnimation } from "./animations/md.leave";
 import { createSheetGesture } from "./gestures/sheet";
 import { createSwipeToCloseGesture, SwipeToCloseDefaults } from "./gestures/swipe-to-close";
-import { getInitialSafeAreaConfig, getPositionBasedSafeAreaConfig, applySafeAreaOverrides, clearSafeAreaOverrides, getRootSafeAreaTop, onRootSafeAreaTopChange, hasCustomModalDimensions, } from "./safe-area-utils";
-import { setCardStatusBarDark, setCardStatusBarDefault } from "./utils";
+import { getInitialSafeAreaConfig, getPositionBasedSafeAreaConfig, applySafeAreaOverrides, clearSafeAreaOverrides, getRootSafeAreaTop, onRootSafeAreaTopChange, getModalCoveredAxes, } from "./safe-area-utils";
+import { onModalHeightChange, setCardStatusBarDark, setCardStatusBarDefault } from "./utils";
 // TODO(FW-2832): types
 /**
  * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
@@ -1053,7 +1053,7 @@ export class Modal {
     /**
      * Creates the context object for safe-area utilities.
      *
-     * `hasCustomDimensions` is only set by `setInitialSafeAreaOverrides()`
+     * `coveredAxes` is only set by `setInitialSafeAreaOverrides()`
      * because it is only read by `getInitialSafeAreaConfig()`. Other callers
      * (resize handler, post-animation update, fullscreen-padding apply) would
      * pay a `getComputedStyle()` cost for a value they never consult.
@@ -1067,6 +1067,26 @@ export class Modal {
             currentBreakpoint: this.currentBreakpoint,
         };
     }
+    /**
+     * Keeps the content's sizing in sync with `--height`. The content reads the
+     * property to determine whether it should size itself to its content, and
+     * changes to `--height` on an ancestor or the root can change that behavior
+     * without changing the modal itself.
+     */
+    watchHeightForContent() {
+        /**
+         * A sheet's height comes from its breakpoints, so its content never sizes
+         * itself to `--height`. Watching it would cause the drag to recalculate on
+         * every frame.
+         */
+        if (this.isSheetModal) {
+            return;
+        }
+        this.unsubscribeHeightChange?.();
+        this.unsubscribeHeightChange = onModalHeightChange(this.el, () => {
+            this.el.querySelectorAll('ion-content').forEach((contentEl) => contentEl.recalculateDimensions());
+        });
+    }
     /**
      * Sets initial safe-area overrides before modal animation.
      * Called in present() before animation starts.
@@ -1080,10 +1100,11 @@ export class Modal {
     setInitialSafeAreaOverrides() {
         const context = {
             ...this.getSafeAreaContext(),
-            hasCustomDimensions: hasCustomModalDimensions(this.el),
+            coveredAxes: getModalCoveredAxes(this.el),
         };
         const safeAreaConfig = getInitialSafeAreaConfig(context);
         applySafeAreaOverrides(this.el, safeAreaConfig);
+        this.watchHeightForContent();
         // Set the internal offset property with the resolved root safe-area-top value
         if (context.isSheetModal) {
             this.updateSheetOffsetTop();
@@ -1203,6 +1224,8 @@ export class Modal {
         clearSafeAreaOverrides(this.el);
         this.unsubscribeRootSafeAreaTop?.();
         this.unsubscribeRootSafeAreaTop = undefined;
+        this.unsubscribeHeightChange?.();
+        this.unsubscribeHeightChange = undefined;
         // Remove internal sheet offset property
         this.el.style.removeProperty('--ion-modal-offset-top');
         const { contentEl } = this.findContentAndFooter();
@@ -1240,7 +1263,7 @@ export class Modal {
         const isCardModal = presentingElement !== undefined && mode === 'ios';
         const isHandleCycle = handleBehavior === 'cycle';
         const isSheetModalWithHandle = isSheetModal && showHandle;
-        return (h(Host, { key: '7c9c736052c5a788cf31040b6b2386dd9ea7454b', "no-router": true,
+        return (h(Host, { key: '17a95bd7722bac2344bea041aff97db17f55c0cf', "no-router": true,
             // Allow the modal to be navigable when the handle is focusable
             tabIndex: isHandleCycle && isSheetModalWithHandle ? 0 : -1, ...htmlAttributes, style: {
                 zIndex: `${20000 + this.overlayIndex}`,
@@ -1253,7 +1276,7 @@ export class Modal {
                 'overlay-hidden': true,
                 [FOCUS_TRAP_DISABLE_CLASS]: focusTrap === false,
                 ...getClassMap(this.cssClass),
-            }, onIonBackdropTap: this.onBackdropTap, onIonModalDidPresent: this.onLifecycle, onIonModalWillPresent: this.onLifecycle, onIonModalWillDismiss: this.onLifecycle, onIonModalDidDismiss: this.onLifecycle, onFocus: this.onModalFocus }, h("ion-backdrop", { key: '01b5b5765fb3a32393c736065c824bf760728823', ref: (el) => (this.backdropEl = el), visible: this.showBackdrop, tappable: this.backdropDismiss, part: "backdrop" }), mode === 'ios' && h("div", { key: '40fa7727a0923f7d7461dd027f1511a6a148d84a', class: "modal-shadow" }), h("div", { key: '9af934b607f60795bd5bff7bee6eacfc9b14fa35',
+            }, onIonBackdropTap: this.onBackdropTap, onIonModalDidPresent: this.onLifecycle, onIonModalWillPresent: this.onLifecycle, onIonModalWillDismiss: this.onLifecycle, onIonModalDidDismiss: this.onLifecycle, onFocus: this.onModalFocus }, h("ion-backdrop", { key: '9dab1ef4771c0d847ba2be8672afbaa2748517f3', ref: (el) => (this.backdropEl = el), visible: this.showBackdrop, tappable: this.backdropDismiss, part: "backdrop" }), mode === 'ios' && h("div", { key: '64af7ed1c5f552b61fc4b9387b926acc76c8a99a', class: "modal-shadow" }), h("div", { key: '7e76d77d5b2e8f0467bb793facf5aa86f8d01bbe',
             /*
               role and aria-modal must be used on the
               same element. They must also be set inside the
@@ -1266,9 +1289,9 @@ export class Modal {
               without the tabindex focus() would be a no-op and screen readers
               may not properly announce the dialog and its content when it opens.
             */
-            role: "dialog", ...inheritedAttributes, "aria-modal": "true", tabIndex: -1, class: "modal-wrapper ion-overlay-wrapper", part: "content", ref: (el) => (this.wrapperEl = el) }, showHandle && (h("button", { key: 'df84a6806413b13efc5b03c862edde83151579a7', class: "modal-handle",
+            role: "dialog", ...inheritedAttributes, "aria-modal": "true", tabIndex: -1, class: "modal-wrapper ion-overlay-wrapper", part: "content", ref: (el) => (this.wrapperEl = el) }, showHandle && (h("button", { key: '5efc0bb0a59adcc594ac48da9fd90e57908a7ffb', class: "modal-handle",
             // Prevents the handle from receiving keyboard focus when it does not cycle
-            tabIndex: !isHandleCycle ? -1 : 0, "aria-label": "Activate to adjust the size of the dialog overlaying the screen", onClick: isHandleCycle ? this.onHandleClick : undefined, part: "handle", ref: (el) => (this.dragHandleEl = el) })), h("slot", { key: '072d3929ec6f25481946b184d8ac24219011e783', onSlotchange: this.onSlotChange }))));
+            tabIndex: !isHandleCycle ? -1 : 0, "aria-label": "Activate to adjust the size of the dialog overlaying the screen", onClick: isHandleCycle ? this.onHandleClick : undefined, part: "handle", ref: (el) => (this.dragHandleEl = el) })), h("slot", { key: '6175fcd0b39c086b4e9eb9e96c4d631c2a86774b', onSlotchange: this.onSlotChange }))));
     }
     static get is() { return "ion-modal"; }
     static get encapsulation() { return "shadow"; }

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

@@ -77,7 +77,12 @@
   --max-width: auto;
   --height: 100%;
   --min-height: auto;
-  --max-height: auto;
+  /**
+   * Clamps a content-sized `--height` (auto, fit-content, ...) to the
+   * overlay, giving the wrapper's flex children something to shrink
+   * toward so `ion-content` scrolls instead of overflowing.
+   */
+  --max-height: 100%;
   --overflow: hidden;
   --border-radius: 0;
   --border-width: 0;
@@ -129,8 +134,14 @@ ion-backdrop {
 /**
  * The wrapper receives programmatic focus for screen readers but should not
  * show a visible focus ring, which is meant only for keyboard navigation.
+ *
+ * A flex layout is required for the wrapper to size itself to its content
+ * when the modal is content-sized (`--height` is auto, fit-content, ...).
+ * This makes it so that the content can scroll when it overflows the wrapper.
  */
 .modal-wrapper {
+  display: flex;
+  flex-direction: column;
   outline: none;
 }
 

package/dist/collection/components/modal/safe-area-utils.js

@@ -2,41 +2,14 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { win } from "../../utils/browser/index";
-import { raf } from "../../utils/helpers";
-/**
- * These thresholds match the SCSS media query breakpoints in modal.vars.scss
- * that trigger the centered dialog layout (non-fullscreen modal).
- *
- * SCSS defines two height breakpoints: $modal-inset-min-height-small (600px)
- * and $modal-inset-min-height-large (768px). We use the smaller one because
- * that's the threshold where the modal transitions from fullscreen to centered
- * dialog — the larger breakpoint only increases the dialog's height.
- */
-const MODAL_INSET_MIN_WIDTH = 768;
-const MODAL_INSET_MIN_HEIGHT = 600;
+import { onCustomPropertyChange, raf } from "../../utils/helpers";
+import { getOverlaySizeType } from "../../utils/overlays";
 const EDGE_THRESHOLD = 5;
-/**
- * CSS values for `--width` / `--height` that are treated as fullscreen
- * (modal touches the corresponding screen edges). Empty string means the
- * property was not overridden. See `hasCustomModalDimensions()`.
- */
-const FULLSCREEN_SIZE_VALUES = new Set(['', '100%', '100vw', '100vh', '100dvw', '100dvh', '100svw', '100svh']);
 /**
  * Cache for resolved root safe-area-top value, invalidated once per frame.
  */
 let cachedRootSafeAreaTop = null;
 let cacheInvalidationScheduled = false;
-/**
- * Determines if the current viewport meets the CSS media query conditions
- * that cause regular modals to render as centered dialogs instead of fullscreen.
- * Matches: @media (min-width: 768px) and (min-height: 600px)
- */
-const isCenteredDialogViewport = () => {
-    if (!win)
-        return false;
-    return win.matchMedia(`(min-width: ${MODAL_INSET_MIN_WIDTH}px) and (min-height: ${MODAL_INSET_MIN_HEIGHT}px)`)
-        .matches;
-};
 /**
  * Resolves the current root --ion-safe-area-top value to pixels.
  * Uses a temporary element because getComputedStyle on :root returns
@@ -70,55 +43,64 @@ export const getRootSafeAreaTop = () => {
     return value;
 };
 /**
- * Calls back when the resolved root `--ion-safe-area-top` changes, which no
- * event and no window resize covers. The probe's height tracks the variable, so
- * a change to it becomes a size change the observer can see.
+ * Calls back when the resolved root `--ion-safe-area-top` changes. The value
+ * the caller already applied is passed as the baseline, so a change between
+ * that read and the observer starting is still reported.
  */
 export const onRootSafeAreaTopChange = (callback) => {
-    const doc = win?.document;
-    if (!doc?.body || typeof ResizeObserver === 'undefined') {
-        return () => undefined;
-    }
-    const probe = doc.createElement('div');
-    probe.style.cssText =
-        'position:fixed;visibility:hidden;pointer-events:none;top:0;left:0;width:0;' +
-            'height:var(--ion-safe-area-top,0px);';
-    doc.body.appendChild(probe);
-    /**
-     * Seeded with the value the caller has already applied, so a change that
-     * lands before the observer's first delivery still gets reported. Comparing
-     * against an unset value instead would consume that first delivery and treat
-     * the new inset as the baseline.
-     */
-    let lastHeight = getRootSafeAreaTop();
-    const observer = new ResizeObserver((entries) => {
-        const { height } = entries[0].contentRect;
-        if (height !== lastHeight) {
-            lastHeight = height;
-            callback(height);
-        }
-    });
-    observer.observe(probe);
-    return () => {
-        observer.disconnect();
-        probe.remove();
-    };
+    return onCustomPropertyChange(win?.document?.body, '--ion-safe-area-top', callback, getRootSafeAreaTop());
 };
 /**
- * True when the modal host declares BOTH a non-fullscreen `--width` AND a
- * non-fullscreen `--height` (i.e. a centered-dialog-like modal that doesn't
- * touch any screen edge).
+ * Determines which viewport axes the modal spans so safe-area requirements
+ * can be predicted independently for each axis.
  *
- * The conservative "both axes" check avoids mis-zeroing safe-area for
- * partial-custom modals where the modal still touches top/bottom edges
- * (e.g. only `--width` overridden). Partial cases fall through to the
- * existing position-based post-animation correction.
+ * A modal that spans an axis reaches both edges on that axis and needs the
+ * corresponding safe-area insets. A modal that does not span an axis reaches
+ * neither edge on that axis.
+ *
+ * When both `--width` and `--height` are `fullscreen`, coverage can be
+ * determined directly. Otherwise, coverage is based on the rendered wrapper,
+ * including cases where content sizing or `--max-height` causes the modal
+ * to reach the viewport.
  */
-export const hasCustomModalDimensions = (hostEl) => {
+export const getModalCoveredAxes = (hostEl) => {
     const styles = getComputedStyle(hostEl);
-    const width = styles.getPropertyValue('--width').trim();
-    const height = styles.getPropertyValue('--height').trim();
-    return !FULLSCREEN_SIZE_VALUES.has(width) && !FULLSCREEN_SIZE_VALUES.has(height);
+    const width = getOverlaySizeType(styles.getPropertyValue('--width'));
+    const height = getOverlaySizeType(styles.getPropertyValue('--height'));
+    if (width === 'fullscreen' && height === 'fullscreen') {
+        return { vertical: true, horizontal: true };
+    }
+    return measureCoveredAxes(hostEl);
+};
+/**
+ * Measures the modal wrapper to determine whether it spans the viewport
+ * on each axis.
+ *
+ * The wrapper has no box while the modal is hidden, so `overlay-hidden`
+ * is temporarily removed to allow the wrapper to be measured. The class
+ * is restored in the same task before the browser can paint.
+ *
+ * Only the wrapper's size is measured. Its position is affected by the
+ * enter animation, which initially translates it by its own height, while
+ * the translation does not affect its measured size.
+ */
+const measureCoveredAxes = (hostEl) => {
+    const wrapperEl = hostEl.shadowRoot?.querySelector('.modal-wrapper');
+    if (wrapperEl == null || win === undefined) {
+        return { vertical: false, horizontal: false };
+    }
+    const wasHidden = hostEl.classList.contains('overlay-hidden');
+    if (wasHidden) {
+        hostEl.classList.remove('overlay-hidden');
+    }
+    const { width, height } = wrapperEl.getBoundingClientRect();
+    if (wasHidden) {
+        hostEl.classList.add('overlay-hidden');
+    }
+    return {
+        vertical: height >= win.innerHeight - EDGE_THRESHOLD,
+        horizontal: width >= win.innerWidth - EDGE_THRESHOLD,
+    };
 };
 /**
  * Returns the initial safe-area configuration based on modal type.
@@ -152,26 +134,23 @@ export const getInitialSafeAreaConfig = (context) => {
             right: '0px',
         };
     }
-    // On viewports that meet the centered dialog media query breakpoints,
-    // regular modals render as centered dialogs (not fullscreen), so they
-    // don't touch any screen edges and don't need safe-area insets. Also
-    // applies to phone viewports when the modal declares custom --width and
-    // --height; these don't touch screen edges either, so the initial
-    // prediction must be zero to avoid a post-animation correction flash.
-    if (isCenteredDialogViewport() || context.hasCustomDimensions) {
-        return {
-            top: '0px',
-            bottom: '0px',
-            left: '0px',
-            right: '0px',
-        };
-    }
-    // Fullscreen modals on phone - inherit all safe areas
+    /**
+     * Each axis is evaluated independently because a modal can span one axis
+     * without spanning the other. This allows the initial safe-area configuration
+     * to match the modal's expected dimensions and avoids correcting an incorrect
+     * pair of insets after presentation.
+     *
+     * A modal can span the horizontal axis while remaining inset vertically, or
+     * span the vertical axis while remaining inset horizontally. Wide viewports
+     * can also render regular modals as centered dialogs, while content-sized
+     * modals may still be clamped to the viewport.
+     */
+    const { vertical, horizontal } = context.coveredAxes ?? { vertical: true, horizontal: true };
     return {
-        top: 'inherit',
-        bottom: 'inherit',
-        left: 'inherit',
-        right: 'inherit',
+        top: vertical ? 'inherit' : '0px',
+        bottom: vertical ? 'inherit' : '0px',
+        left: horizontal ? 'inherit' : '0px',
+        right: horizontal ? 'inherit' : '0px',
     };
 };
 /**

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

@@ -2,6 +2,7 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { win } from "../../utils/browser/index";
+import { onCustomPropertyChange } from "../../utils/helpers";
 import { StatusBar, Style } from "../../utils/native/status-bar";
 /**
  * Use y = mx + b to
@@ -78,3 +79,9 @@ export const setCardStatusBarDefault = (defaultStyle = Style.Default) => {
     }
     StatusBar.setStyle({ style: defaultStyle });
 };
+/**
+ * Calls back when the modal's resolved `--height` changes.
+ */
+export const onModalHeightChange = (hostEl, callback) => {
+    return onCustomPropertyChange(hostEl, '--height', () => callback());
+};

package/dist/collection/components/popover/animations/ios.enter.js

@@ -3,7 +3,7 @@
  */
 import { createAnimation } from "../../../utils/animation/animation";
 import { getElementRoot } from "../../../utils/helpers";
-import { calculateWindowAdjustment, getArrowDimensions, getPopoverDimensions, getPopoverPosition, getSafeAreaInsets, shouldShowArrow, } from "../utils";
+import { calculateWindowAdjustment, getArrowDimensions, getElementCSSZoom, getPopoverDimensions, getPopoverPosition, getSafeAreaInsets, shouldShowArrow, } from "../utils";
 const POPOVER_IOS_BODY_PADDING = 5;
 /**
  * Minimum edge margin for iOS popovers ensures visual spacing from screen
@@ -22,21 +22,35 @@ export const iosEnterAnimation = (baseEl, opts) => {
     const { event: ev, size, trigger, reference, side, align } = opts;
     const doc = baseEl.ownerDocument;
     const isRTL = doc.dir === 'rtl';
-    const bodyWidth = doc.defaultView.innerWidth;
-    const bodyHeight = doc.defaultView.innerHeight;
     const root = getElementRoot(baseEl);
     const contentEl = root.querySelector('.popover-content');
     const arrowEl = root.querySelector('.popover-arrow');
+    /**
+     * A CSS `zoom` other than 1 on an ancestor (e.g. the `html` element) causes
+     * geometry APIs like `getBoundingClientRect()` to report zoomed values while
+     * inline `top`/`left`/`--width` styles are interpreted in the unzoomed layout
+     * space. Normalize all rect-derived measurements by this factor so the
+     * popover is positioned and sized correctly.
+     */
+    const zoom = getElementCSSZoom(contentEl);
+    /**
+     * `innerWidth`/`innerHeight` are not affected by CSS `zoom`, so they must be
+     * scaled down to the same layout space as the normalized measurements above.
+     * Otherwise the popover would be clamped against a viewport that is larger
+     * than the space actually available to it.
+     */
+    const bodyWidth = doc.defaultView.innerWidth / zoom;
+    const bodyHeight = doc.defaultView.innerHeight / zoom;
     const referenceSizeEl = trigger || ev?.detail?.ionShadowTarget || ev?.target;
-    const { contentWidth, contentHeight } = getPopoverDimensions(size, contentEl, referenceSizeEl);
-    const { arrowWidth, arrowHeight } = getArrowDimensions(arrowEl);
+    const { contentWidth, contentHeight } = getPopoverDimensions(size, contentEl, referenceSizeEl, zoom);
+    const { arrowWidth, arrowHeight } = getArrowDimensions(arrowEl, zoom);
     const defaultPosition = {
         top: bodyHeight / 2 - contentHeight / 2,
         left: bodyWidth / 2 - contentWidth / 2,
         originX: isRTL ? 'right' : 'left',
         originY: 'top',
     };
-    const results = getPopoverPosition(isRTL, contentWidth, contentHeight, arrowWidth, arrowHeight, reference, side, align, defaultPosition, trigger, ev);
+    const results = getPopoverPosition(isRTL, contentWidth, contentHeight, arrowWidth, arrowHeight, reference, side, align, defaultPosition, trigger, ev, zoom);
     const padding = size === 'cover' ? 0 : POPOVER_IOS_BODY_PADDING;
     const rawSafeArea = getSafeAreaInsets(doc);
     const safeArea = size === 'cover'

package/dist/collection/components/popover/animations/md.enter.js

@@ -3,7 +3,7 @@
  */
 import { createAnimation } from "../../../utils/animation/animation";
 import { getElementRoot } from "../../../utils/helpers";
-import { calculateWindowAdjustment, getPopoverDimensions, getPopoverPosition, getSafeAreaInsets } from "../utils";
+import { calculateWindowAdjustment, getElementCSSZoom, getPopoverDimensions, getPopoverPosition, getSafeAreaInsets, } from "../utils";
 const POPOVER_MD_BODY_PADDING = 12;
 /**
  * Md Popover Enter Animation
@@ -13,19 +13,33 @@ export const mdEnterAnimation = (baseEl, opts) => {
     const { event: ev, size, trigger, reference, side, align } = opts;
     const doc = baseEl.ownerDocument;
     const isRTL = doc.dir === 'rtl';
-    const bodyWidth = doc.defaultView.innerWidth;
-    const bodyHeight = doc.defaultView.innerHeight;
     const root = getElementRoot(baseEl);
     const contentEl = root.querySelector('.popover-content');
+    /**
+     * A CSS `zoom` other than 1 on an ancestor (e.g. the `html` element) causes
+     * geometry APIs like `getBoundingClientRect()` to report zoomed values while
+     * inline `top`/`left`/`--width` styles are interpreted in the unzoomed layout
+     * space. Normalize all rect-derived measurements by this factor so the
+     * popover is positioned and sized correctly.
+     */
+    const zoom = getElementCSSZoom(contentEl);
+    /**
+     * `innerWidth`/`innerHeight` are not affected by CSS `zoom`, so they must be
+     * scaled down to the same layout space as the normalized measurements above.
+     * Otherwise the popover would be clamped against a viewport that is larger
+     * than the space actually available to it.
+     */
+    const bodyWidth = doc.defaultView.innerWidth / zoom;
+    const bodyHeight = doc.defaultView.innerHeight / zoom;
     const referenceSizeEl = trigger || ev?.detail?.ionShadowTarget || ev?.target;
-    const { contentWidth, contentHeight } = getPopoverDimensions(size, contentEl, referenceSizeEl);
+    const { contentWidth, contentHeight } = getPopoverDimensions(size, contentEl, referenceSizeEl, zoom);
     const defaultPosition = {
         top: bodyHeight / 2 - contentHeight / 2,
         left: bodyWidth / 2 - contentWidth / 2,
         originX: isRTL ? 'right' : 'left',
         originY: 'top',
     };
-    const results = getPopoverPosition(isRTL, contentWidth, contentHeight, 0, 0, reference, side, align, defaultPosition, trigger, ev);
+    const results = getPopoverPosition(isRTL, contentWidth, contentHeight, 0, 0, reference, side, align, defaultPosition, trigger, ev, zoom);
     const padding = size === 'cover' ? 0 : POPOVER_MD_BODY_PADDING;
     // MD mode now applies safe-area insets (previously passed 0, ignoring all safe areas).
     // This is needed for Android edge-to-edge (API 36+) where system bars overlap content.

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

@@ -54,30 +54,81 @@ export const getSafeAreaInsets = (doc) => {
     }
     return insets;
 };
+/**
+ * Largest difference from 1 that the `offsetWidth` based zoom detection below
+ * attributes to integer rounding rather than to an actual CSS `zoom`. The
+ * rounding error is at most half a pixel over the width of the popover, which
+ * is well under this threshold for any realistic popover size.
+ */
+const ZOOM_ROUNDING_TOLERANCE = 0.01;
+/**
+ * Returns the cumulative CSS `zoom` factor applied to an element.
+ *
+ * When a CSS `zoom` other than 1 is set on an ancestor (e.g. the `html`
+ * element, as recommended by the docs for dynamic font scaling on Chrome for
+ * Android), `getBoundingClientRect()`, `clientX`/`clientY` and other geometry
+ * APIs report values in the *zoomed* (visual) coordinate space, while inline
+ * `top`/`left`/`--width` styles we set are interpreted in the *unzoomed*
+ * (layout) space and re-scaled by the browser. Dividing the rect-derived
+ * values by this factor converts them back to layout space so the popover is
+ * positioned and sized correctly. Returns 1 when no zoom is applied.
+ */
+export const getElementCSSZoom = (el) => {
+    if (!el) {
+        return 1;
+    }
+    /**
+     * `currentCSSZoom` exposes the exact effective zoom of an element
+     * (Chromium 128+). When available we use it directly.
+     */
+    const currentCSSZoom = el.currentCSSZoom;
+    if (typeof currentCSSZoom === 'number' && currentCSSZoom > 0) {
+        return currentCSSZoom;
+    }
+    /**
+     * Fallback for browsers without `currentCSSZoom`: compare the rendered
+     * (zoomed) width from `getBoundingClientRect()` against the layout width
+     * from `offsetWidth`, which is not affected by CSS `zoom`.
+     */
+    const { width } = el.getBoundingClientRect();
+    const { offsetWidth } = el;
+    if (offsetWidth > 0 && width > 0) {
+        const ratio = width / offsetWidth;
+        /**
+         * `offsetWidth` is rounded to an integer while the bounding rect is not,
+         * so the ratio is rarely exactly 1 even when no zoom is applied. Treat
+         * sub-pixel differences as "no zoom" so that unzoomed popovers are not
+         * shifted by the rounding error. A real zoom deviates far more, though
+         * the same rounding leaves the detected factor approximate.
+         */
+        return Math.abs(ratio - 1) < ZOOM_ROUNDING_TOLERANCE ? 1 : ratio;
+    }
+    return 1;
+};
 /**
  * Returns the dimensions of the popover
  * arrow on `ios` mode. If arrow is disabled
  * returns (0, 0).
  */
-export const getArrowDimensions = (arrowEl) => {
+export const getArrowDimensions = (arrowEl, zoom = 1) => {
     if (!arrowEl) {
         return { arrowWidth: 0, arrowHeight: 0 };
     }
     const { width, height } = arrowEl.getBoundingClientRect();
-    return { arrowWidth: width, arrowHeight: height };
+    return { arrowWidth: width / zoom, arrowHeight: height / zoom };
 };
 /**
  * Returns the recommended dimensions of the popover
  * that takes into account whether or not the width
  * should match the trigger width.
  */
-export const getPopoverDimensions = (size, contentEl, triggerEl) => {
+export const getPopoverDimensions = (size, contentEl, triggerEl, zoom = 1) => {
     const contentDimentions = contentEl.getBoundingClientRect();
-    const contentHeight = contentDimentions.height;
-    let contentWidth = contentDimentions.width;
+    const contentHeight = contentDimentions.height / zoom;
+    let contentWidth = contentDimentions.width / zoom;
     if (size === 'cover' && triggerEl) {
         const triggerDimensions = triggerEl.getBoundingClientRect();
-        contentWidth = triggerDimensions.width;
+        contentWidth = triggerDimensions.width / zoom;
     }
     return {
         contentWidth,
@@ -419,7 +470,7 @@ export const configureKeyboardInteraction = (popoverEl) => {
  * the reference point, preferred side, alignment
  * and viewport dimensions.
  */
-export const getPopoverPosition = (isRTL, contentWidth, contentHeight, arrowWidth, arrowHeight, reference, side, align, defaultPosition, triggerEl, event) => {
+export const getPopoverPosition = (isRTL, contentWidth, contentHeight, arrowWidth, arrowHeight, reference, side, align, defaultPosition, triggerEl, event, zoom = 1) => {
     let referenceCoordinates = {
         top: 0,
         left: 0,
@@ -438,8 +489,8 @@ export const getPopoverPosition = (isRTL, contentWidth, contentHeight, arrowWidt
             }
             const mouseEv = event;
             referenceCoordinates = {
-                top: mouseEv.clientY,
-                left: mouseEv.clientX,
+                top: mouseEv.clientY / zoom,
+                left: mouseEv.clientX / zoom,
                 width: 1,
                 height: 1,
             };
@@ -471,10 +522,10 @@ export const getPopoverPosition = (isRTL, contentWidth, contentHeight, arrowWidt
             }
             const triggerBoundingBox = actualTriggerEl.getBoundingClientRect();
             referenceCoordinates = {
-                top: triggerBoundingBox.top,
-                left: triggerBoundingBox.left,
-                width: triggerBoundingBox.width,
-                height: triggerBoundingBox.height,
+                top: triggerBoundingBox.top / zoom,
+                left: triggerBoundingBox.left / zoom,
+                width: triggerBoundingBox.width / zoom,
+                height: triggerBoundingBox.height / zoom,
             };
             break;
     }

package/dist/collection/components/select/select.ios.css

@@ -204,7 +204,7 @@ button {
 
 .select-text {
   flex: 1;
-  min-width: 16px;
+  min-width: 2ch;
   font-size: inherit;
   text-overflow: ellipsis;
   white-space: inherit;