@ionic/core 7.7.2-dev.11707881769.185d2a14 → 7.7.2-dev.11707932366.16baf005

package/dist/collection/components/picker-legacy-column/picker-column.js

@@ -0,0 +1,419 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { Host, h } from "@stencil/core";
+import { clamp } from "../../utils/helpers";
+import { hapticSelectionChanged, hapticSelectionEnd, hapticSelectionStart } from "../../utils/native/haptic";
+import { getClassMap } from "../../utils/theme";
+import { getIonMode } from "../../global/ionic-global";
+/**
+ * @internal
+ */
+export class PickerColumnCmp {
+    constructor() {
+        this.optHeight = 0;
+        this.rotateFactor = 0;
+        this.scaleFactor = 1;
+        this.velocity = 0;
+        this.y = 0;
+        this.noAnimate = true;
+        // `colDidChange` is a flag that gets set when the column is changed
+        // dynamically. When this flag is set, the column will refresh
+        // after the component re-renders to incorporate the new column data.
+        // This is necessary because `this.refresh` queries for the option elements,
+        // so it needs to wait for the latest elements to be available in the DOM.
+        // Ex: column is created with 3 options. User updates the column data
+        // to have 5 options. The column will still think it only has 3 options.
+        this.colDidChange = false;
+        this.col = undefined;
+    }
+    colChanged() {
+        this.colDidChange = true;
+    }
+    async connectedCallback() {
+        let pickerRotateFactor = 0;
+        let pickerScaleFactor = 0.81;
+        const mode = getIonMode(this);
+        if (mode === 'ios') {
+            pickerRotateFactor = -0.46;
+            pickerScaleFactor = 1;
+        }
+        this.rotateFactor = pickerRotateFactor;
+        this.scaleFactor = pickerScaleFactor;
+        this.gesture = (await import('../../utils/gesture')).createGesture({
+            el: this.el,
+            gestureName: 'picker-swipe',
+            gesturePriority: 100,
+            threshold: 0,
+            passive: false,
+            onStart: (ev) => this.onStart(ev),
+            onMove: (ev) => this.onMove(ev),
+            onEnd: (ev) => this.onEnd(ev),
+        });
+        this.gesture.enable();
+        // Options have not been initialized yet
+        // Animation must be disabled through the `noAnimate` flag
+        // Otherwise, the options will render
+        // at the top of the column and transition down
+        this.tmrId = setTimeout(() => {
+            this.noAnimate = false;
+            // After initialization, `refresh()` will be called
+            // At this point, animation will be enabled. The options will
+            // animate as they are being selected.
+            this.refresh(true);
+        }, 250);
+    }
+    componentDidLoad() {
+        this.onDomChange();
+    }
+    componentDidUpdate() {
+        // Options may have changed since last update.
+        if (this.colDidChange) {
+            // Animation must be disabled through the `onDomChange` parameter.
+            // Otherwise, the recently added options will render
+            // at the top of the column and transition down
+            this.onDomChange(true, false);
+            this.colDidChange = false;
+        }
+    }
+    disconnectedCallback() {
+        if (this.rafId !== undefined)
+            cancelAnimationFrame(this.rafId);
+        if (this.tmrId)
+            clearTimeout(this.tmrId);
+        if (this.gesture) {
+            this.gesture.destroy();
+            this.gesture = undefined;
+        }
+    }
+    emitColChange() {
+        this.ionPickerColChange.emit(this.col);
+    }
+    setSelected(selectedIndex, duration) {
+        // if there is a selected index, then figure out it's y position
+        // if there isn't a selected index, then just use the top y position
+        const y = selectedIndex > -1 ? -(selectedIndex * this.optHeight) : 0;
+        this.velocity = 0;
+        // set what y position we're at
+        if (this.rafId !== undefined)
+            cancelAnimationFrame(this.rafId);
+        this.update(y, duration, true);
+        this.emitColChange();
+    }
+    update(y, duration, saveY) {
+        if (!this.optsEl) {
+            return;
+        }
+        // ensure we've got a good round number :)
+        let translateY = 0;
+        let translateZ = 0;
+        const { col, rotateFactor } = this;
+        const prevSelected = col.selectedIndex;
+        const selectedIndex = (col.selectedIndex = this.indexForY(-y));
+        const durationStr = duration === 0 ? '' : duration + 'ms';
+        const scaleStr = `scale(${this.scaleFactor})`;
+        const children = this.optsEl.children;
+        for (let i = 0; i < children.length; i++) {
+            const button = children[i];
+            const opt = col.options[i];
+            const optOffset = i * this.optHeight + y;
+            let transform = '';
+            if (rotateFactor !== 0) {
+                const rotateX = optOffset * rotateFactor;
+                if (Math.abs(rotateX) <= 90) {
+                    translateY = 0;
+                    translateZ = 90;
+                    transform = `rotateX(${rotateX}deg) `;
+                }
+                else {
+                    translateY = -9999;
+                }
+            }
+            else {
+                translateZ = 0;
+                translateY = optOffset;
+            }
+            const selected = selectedIndex === i;
+            transform += `translate3d(0px,${translateY}px,${translateZ}px) `;
+            if (this.scaleFactor !== 1 && !selected) {
+                transform += scaleStr;
+            }
+            // Update transition duration
+            if (this.noAnimate) {
+                opt.duration = 0;
+                button.style.transitionDuration = '';
+            }
+            else if (duration !== opt.duration) {
+                opt.duration = duration;
+                button.style.transitionDuration = durationStr;
+            }
+            // Update transform
+            if (transform !== opt.transform) {
+                opt.transform = transform;
+            }
+            button.style.transform = transform;
+            /**
+             * Ensure that the select column
+             * item has the selected class
+             */
+            opt.selected = selected;
+            if (selected) {
+                button.classList.add(PICKER_OPT_SELECTED);
+            }
+            else {
+                button.classList.remove(PICKER_OPT_SELECTED);
+            }
+        }
+        this.col.prevSelected = prevSelected;
+        if (saveY) {
+            this.y = y;
+        }
+        if (this.lastIndex !== selectedIndex) {
+            // have not set a last index yet
+            hapticSelectionChanged();
+            this.lastIndex = selectedIndex;
+        }
+    }
+    decelerate() {
+        if (this.velocity !== 0) {
+            // still decelerating
+            this.velocity *= DECELERATION_FRICTION;
+            // do not let it go slower than a velocity of 1
+            this.velocity = this.velocity > 0 ? Math.max(this.velocity, 1) : Math.min(this.velocity, -1);
+            let y = this.y + this.velocity;
+            if (y > this.minY) {
+                // whoops, it's trying to scroll up farther than the options we have!
+                y = this.minY;
+                this.velocity = 0;
+            }
+            else if (y < this.maxY) {
+                // gahh, it's trying to scroll down farther than we can!
+                y = this.maxY;
+                this.velocity = 0;
+            }
+            this.update(y, 0, true);
+            const notLockedIn = Math.round(y) % this.optHeight !== 0 || Math.abs(this.velocity) > 1;
+            if (notLockedIn) {
+                // isn't locked in yet, keep decelerating until it is
+                this.rafId = requestAnimationFrame(() => this.decelerate());
+            }
+            else {
+                this.velocity = 0;
+                this.emitColChange();
+                hapticSelectionEnd();
+            }
+        }
+        else if (this.y % this.optHeight !== 0) {
+            // needs to still get locked into a position so options line up
+            const currentPos = Math.abs(this.y % this.optHeight);
+            // create a velocity in the direction it needs to scroll
+            this.velocity = currentPos > this.optHeight / 2 ? 1 : -1;
+            this.decelerate();
+        }
+    }
+    indexForY(y) {
+        return Math.min(Math.max(Math.abs(Math.round(y / this.optHeight)), 0), this.col.options.length - 1);
+    }
+    onStart(detail) {
+        // We have to prevent default in order to block scrolling under the picker
+        // but we DO NOT have to stop propagation, since we still want
+        // some "click" events to capture
+        if (detail.event.cancelable) {
+            detail.event.preventDefault();
+        }
+        detail.event.stopPropagation();
+        hapticSelectionStart();
+        // reset everything
+        if (this.rafId !== undefined)
+            cancelAnimationFrame(this.rafId);
+        const options = this.col.options;
+        let minY = options.length - 1;
+        let maxY = 0;
+        for (let i = 0; i < options.length; i++) {
+            if (!options[i].disabled) {
+                minY = Math.min(minY, i);
+                maxY = Math.max(maxY, i);
+            }
+        }
+        this.minY = -(minY * this.optHeight);
+        this.maxY = -(maxY * this.optHeight);
+    }
+    onMove(detail) {
+        if (detail.event.cancelable) {
+            detail.event.preventDefault();
+        }
+        detail.event.stopPropagation();
+        // update the scroll position relative to pointer start position
+        let y = this.y + detail.deltaY;
+        if (y > this.minY) {
+            // scrolling up higher than scroll area
+            y = Math.pow(y, 0.8);
+            this.bounceFrom = y;
+        }
+        else if (y < this.maxY) {
+            // scrolling down below scroll area
+            y += Math.pow(this.maxY - y, 0.9);
+            this.bounceFrom = y;
+        }
+        else {
+            this.bounceFrom = 0;
+        }
+        this.update(y, 0, false);
+    }
+    onEnd(detail) {
+        if (this.bounceFrom > 0) {
+            // bounce back up
+            this.update(this.minY, 100, true);
+            this.emitColChange();
+            return;
+        }
+        else if (this.bounceFrom < 0) {
+            // bounce back down
+            this.update(this.maxY, 100, true);
+            this.emitColChange();
+            return;
+        }
+        this.velocity = clamp(-MAX_PICKER_SPEED, detail.velocityY * 23, MAX_PICKER_SPEED);
+        if (this.velocity === 0 && detail.deltaY === 0) {
+            const opt = detail.event.target.closest('.picker-opt');
+            if (opt === null || opt === void 0 ? void 0 : opt.hasAttribute('opt-index')) {
+                this.setSelected(parseInt(opt.getAttribute('opt-index'), 10), TRANSITION_DURATION);
+            }
+        }
+        else {
+            this.y += detail.deltaY;
+            if (Math.abs(detail.velocityY) < 0.05) {
+                const isScrollingUp = detail.deltaY > 0;
+                const optHeightFraction = (Math.abs(this.y) % this.optHeight) / this.optHeight;
+                if (isScrollingUp && optHeightFraction > 0.5) {
+                    this.velocity = Math.abs(this.velocity) * -1;
+                }
+                else if (!isScrollingUp && optHeightFraction <= 0.5) {
+                    this.velocity = Math.abs(this.velocity);
+                }
+            }
+            this.decelerate();
+        }
+    }
+    refresh(forceRefresh, animated) {
+        var _a;
+        let min = this.col.options.length - 1;
+        let max = 0;
+        const options = this.col.options;
+        for (let i = 0; i < options.length; i++) {
+            if (!options[i].disabled) {
+                min = Math.min(min, i);
+                max = Math.max(max, i);
+            }
+        }
+        /**
+         * Only update selected value if column has a
+         * velocity of 0. If it does not, then the
+         * column is animating might land on
+         * a value different than the value at
+         * selectedIndex
+         */
+        if (this.velocity !== 0) {
+            return;
+        }
+        const selectedIndex = clamp(min, (_a = this.col.selectedIndex) !== null && _a !== void 0 ? _a : 0, max);
+        if (this.col.prevSelected !== selectedIndex || forceRefresh) {
+            const y = selectedIndex * this.optHeight * -1;
+            const duration = animated ? TRANSITION_DURATION : 0;
+            this.velocity = 0;
+            this.update(y, duration, true);
+        }
+    }
+    onDomChange(forceRefresh, animated) {
+        const colEl = this.optsEl;
+        if (colEl) {
+            // DOM READ
+            // We perfom a DOM read over a rendered item, this needs to happen after the first render or after the the column has changed
+            this.optHeight = colEl.firstElementChild ? colEl.firstElementChild.clientHeight : 0;
+        }
+        this.refresh(forceRefresh, animated);
+    }
+    render() {
+        const col = this.col;
+        const mode = getIonMode(this);
+        return (h(Host, { key: 'e842db5f435d9f36ef0842ddcafa3e6d56cc520c', class: Object.assign({ [mode]: true, 'picker-col': true, 'picker-opts-left': this.col.align === 'left', 'picker-opts-right': this.col.align === 'right' }, getClassMap(col.cssClass)), style: {
+                'max-width': this.col.columnWidth,
+            } }, col.prefix && (h("div", { class: "picker-prefix", style: { width: col.prefixWidth } }, col.prefix)), h("div", { key: 'd83fd959cd305d29cd290f3aefef6798e5513dfb', class: "picker-opts", style: { maxWidth: col.optionsWidth }, ref: (el) => (this.optsEl = el) }, col.options.map((o, index) => (h("button", { "aria-label": o.ariaLabel, class: { 'picker-opt': true, 'picker-opt-disabled': !!o.disabled }, "opt-index": index }, o.text)))), col.suffix && (h("div", { class: "picker-suffix", style: { width: col.suffixWidth } }, col.suffix))));
+    }
+    static get is() { return "ion-picker-legacy-column"; }
+    static get originalStyleUrls() {
+        return {
+            "ios": ["picker-column.ios.scss"],
+            "md": ["picker-column.md.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "ios": ["picker-column.ios.css"],
+            "md": ["picker-column.md.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "col": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "PickerColumn",
+                    "resolved": "PickerColumn",
+                    "references": {
+                        "PickerColumn": {
+                            "location": "import",
+                            "path": "../picker-legacy/picker-interface",
+                            "id": "src/components/picker-legacy/picker-interface.ts::PickerColumn"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Picker column data"
+                }
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "ionPickerColChange",
+                "name": "ionPickerColChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "internal",
+                            "text": undefined
+                        }],
+                    "text": "Emitted when the selected value has changed"
+                },
+                "complexType": {
+                    "original": "PickerColumn",
+                    "resolved": "PickerColumn",
+                    "references": {
+                        "PickerColumn": {
+                            "location": "import",
+                            "path": "../picker-legacy/picker-interface",
+                            "id": "src/components/picker-legacy/picker-interface.ts::PickerColumn"
+                        }
+                    }
+                }
+            }];
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "col",
+                "methodName": "colChanged"
+            }];
+    }
+}
+const PICKER_OPT_SELECTED = 'picker-opt-selected';
+const DECELERATION_FRICTION = 0.97;
+const MAX_PICKER_SPEED = 90;
+const TRANSITION_DURATION = 150;

package/dist/collection/components/{picker-column → picker-legacy-column}/picker-column.md.css

@@ -82,32 +82,8 @@
   overflow: hidden;
   will-change: transform;
 }
-@supports (inset-inline-start: 0) {
-  .picker-opt {
-    inset-inline-start: 0;
-  }
-}
-@supports not (inset-inline-start: 0) {
-  .picker-opt {
-    left: 0;
-  }
-  :host-context([dir=rtl]) .picker-opt {
-    left: unset;
-    right: unset;
-    right: 0;
-  }
-  [dir=rtl] .picker-opt {
-    left: unset;
-    right: unset;
-    right: 0;
-  }
-  @supports selector(:dir(rtl)) {
-    .picker-opt:dir(rtl) {
-      left: unset;
-      right: unset;
-      right: 0;
-    }
-  }
+.picker-opt {
+  inset-inline-start: 0;
 }
 
 .picker-opt.picker-opt-disabled {
@@ -242,5 +218,5 @@
 .picker-prefix,
 .picker-suffix,
 .picker-opt.picker-opt-selected {
-  color: var(--ion-color-primary, #3880ff);
+  color: var(--ion-color-primary, #0054e9);
 }

package/dist/collection/components/{picker-column → picker-legacy-column}/test/picker-column-aria.spec.js

@@ -25,10 +25,10 @@ describe('picker-column', () => {
         };
         const page = await newSpecPage({
             components: [PickerColumnCmp],
-            template: () => h("ion-picker-column", { col: col }),
+            template: () => h("ion-picker-legacy-column", { col: col }),
         });
-        const firstOption = page.body.querySelector('ion-picker-column .picker-opt:nth-child(1)');
-        const secondOption = page.body.querySelector('ion-picker-column .picker-opt:nth-child(2)');
+        const firstOption = page.body.querySelector('ion-picker-legacy-column .picker-opt:nth-child(1)');
+        const secondOption = page.body.querySelector('ion-picker-legacy-column .picker-opt:nth-child(2)');
         expect(firstOption.getAttribute('aria-label')).toBe('C Sharp');
         expect(secondOption.getAttribute('aria-label')).toBe(null);
     });

package/dist/collection/components/{picker-column → picker-legacy-column}/test/picker-column-dynamic.spec.js

@@ -15,9 +15,9 @@ describe('picker-column: dynamic options', () => {
         ];
         const page = await newSpecPage({
             components: [PickerColumnCmp],
-            template: () => h("ion-picker-column", { col: { options: defaultOptions, name: 'animals' } }),
+            template: () => (h("ion-picker-legacy-column", { col: { options: defaultOptions, name: 'animals' } })),
         });
-        const pickerCol = page.body.querySelector('ion-picker-column');
+        const pickerCol = page.body.querySelector('ion-picker-legacy-column');
         pickerCol.col = {
             options: [...defaultOptions, { text: 'Carrot', value: 'carrot' }],
             name: 'vegetables',

package/dist/collection/components/{picker-column → picker-legacy-column}/test/picker-column.spec.js

@@ -9,9 +9,9 @@ describe('picker-column', () => {
         const col = { cssClass: 'test-class', options: [], name: 'col' };
         const page = await newSpecPage({
             components: [PickerColumnCmp],
-            template: () => h("ion-picker-column", { col: col }),
+            template: () => h("ion-picker-legacy-column", { col: col }),
         });
-        const pickerCol = page.body.querySelector('ion-picker-column');
+        const pickerCol = page.body.querySelector('ion-picker-legacy-column');
         expect(pickerCol.classList.contains('test-class')).toBe(true);
     });
 });

package/dist/collection/components/{picker-column → picker-legacy-column}/test/standalone/picker-column.e2e.js

@@ -6,11 +6,11 @@ import { configs, test } from "../../../../utils/test/playwright/index";
 configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, config }) => {
     test.describe(title('picker-column'), () => {
         test.beforeEach(async ({ page }) => {
-            await page.goto(`/src/components/picker-column/test/standalone`, config);
+            await page.goto(`/src/components/picker-legacy-column/test/standalone`, config);
         });
         test('should present picker without ion-app', async ({ page }) => {
             const ionPickerDidPresent = await page.spyOnEvent('ionPickerDidPresent');
-            const picker = page.locator('ion-picker');
+            const picker = page.locator('ion-picker-legacy');
             await page.click('#single-column-button');
             await ionPickerDidPresent.next();
             await expect(picker).toBeVisible();
@@ -22,7 +22,7 @@ configs({ modes: ['ios'], directions: ['ltr'] }).forEach(({ title, config }) =>
             });
             const ionPickerDidPresent = await page.spyOnEvent('ionPickerDidPresent');
             const ionPickerColChangeEvent = await page.spyOnEvent('ionPickerColChange');
-            const column = page.locator('ion-picker-column');
+            const column = page.locator('ion-picker-legacy-column');
             const secondOption = column.locator('.picker-opt').nth(1);
             await page.click('#single-column-button');
             await ionPickerDidPresent.next();

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

@@ -249,7 +249,7 @@
 }
 
 :host(.popover-desktop) .popover-content {
-  border: 0.5px solid var(--ion-color-step-100, #e6e6e6);
+  border: 0.5px solid var(--ion-color-step-100, var(--ion-background-color-step-100, #e6e6e6));
 }
 
 .popover-arrow {
@@ -258,13 +258,6 @@
   width: 20px;
   height: 10px;
   overflow: hidden;
-  /*
-   * Required for the arrow to render above the backdrop.
-   * Otherwise, the arrow will appear slightly transparent.
-   * The value is set to 11 since it's the minimum value that
-   * will allow the arrow to render above the backdrop.
-   */
-  z-index: 11;
 }
 
 .popover-arrow::after {
@@ -278,32 +271,8 @@
   content: "";
   z-index: 10;
 }
-@supports (inset-inline-start: 0) {
-  .popover-arrow::after {
-    inset-inline-start: 3px;
-  }
-}
-@supports not (inset-inline-start: 0) {
-  .popover-arrow::after {
-    left: 3px;
-  }
-  :host-context([dir=rtl]) .popover-arrow::after {
-    left: unset;
-    right: unset;
-    right: 3px;
-  }
-  [dir=rtl] .popover-arrow::after {
-    left: unset;
-    right: unset;
-    right: 3px;
-  }
-  @supports selector(:dir(rtl)) {
-    .popover-arrow::after:dir(rtl) {
-      left: unset;
-      right: unset;
-      right: 3px;
-    }
-  }
+.popover-arrow::after {
+  inset-inline-start: 3px;
 }
 
 :host(.popover-bottom) .popover-arrow {

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

@@ -280,10 +280,6 @@ export class Popover {
      * @param role The role of the element that is dismissing the popover. For example, 'cancel' or 'backdrop'.
      * @param dismissParentPopover If `true`, dismissing this popover will also dismiss
      * a parent popover if this popover is nested. Defaults to `true`.
-     *
-     * This is a no-op if the overlay has not been presented yet. If you want
-     * to remove an overlay from the DOM that was never presented, use the
-     * [remove](https://developer.mozilla.org/en-US/docs/Web/API/Element/remove) method.
      */
     async dismiss(data, role, dismissParentPopover = true) {
         const unlock = await this.lockController.lock();
@@ -335,9 +331,9 @@ export class Popover {
         const { onLifecycle, parentPopover, dismissOnSelect, side, arrow, htmlAttributes } = this;
         const desktop = isPlatform('desktop');
         const enableArrow = arrow && !parentPopover;
-        return (h(Host, Object.assign({ key: '104a5bf92a9bbd2efc71d499a8500e5d55f81711', "aria-modal": "true", "no-router": true, tabindex: "-1" }, htmlAttributes, { style: {
+        return (h(Host, Object.assign({ key: '5c65659c22a8190ac3f7488fe97b8fe3545bb32a', "aria-modal": "true", "no-router": true, tabindex: "-1" }, htmlAttributes, { style: {
                 zIndex: `${20000 + this.overlayIndex}`,
-            }, class: Object.assign(Object.assign({}, getClassMap(this.cssClass)), { [mode]: true, 'popover-translucent': this.translucent, 'overlay-hidden': true, 'popover-desktop': desktop, [`popover-side-${side}`]: true, 'popover-nested': !!parentPopover }), onIonPopoverDidPresent: onLifecycle, onIonPopoverWillPresent: onLifecycle, onIonPopoverWillDismiss: onLifecycle, onIonPopoverDidDismiss: onLifecycle, onIonBackdropTap: this.onBackdropTap }), !parentPopover && h("ion-backdrop", { tappable: this.backdropDismiss, visible: this.showBackdrop, part: "backdrop" }), h("div", { key: 'ef0baa04c22444d4bc705220235a892308d67586', class: "popover-wrapper ion-overlay-wrapper", onClick: dismissOnSelect ? () => this.dismiss() : undefined }, enableArrow && h("div", { class: "popover-arrow", part: "arrow" }), h("div", { key: '5cc5f5c353de614e484e9cfeacecfca9fbfde0e0', class: "popover-content", part: "content" }, h("slot", { key: '2d85c591cdc85efa98afbf40f676525f1402efcf' })))));
+            }, class: Object.assign(Object.assign({}, getClassMap(this.cssClass)), { [mode]: true, 'popover-translucent': this.translucent, 'overlay-hidden': true, 'popover-desktop': desktop, [`popover-side-${side}`]: true, 'popover-nested': !!parentPopover }), onIonPopoverDidPresent: onLifecycle, onIonPopoverWillPresent: onLifecycle, onIonPopoverWillDismiss: onLifecycle, onIonPopoverDidDismiss: onLifecycle, onIonBackdropTap: this.onBackdropTap }), !parentPopover && h("ion-backdrop", { tappable: this.backdropDismiss, visible: this.showBackdrop, part: "backdrop" }), h("div", { key: '6055fc5309dadb56d6c17f0a1cb19631e6e5731e', class: "popover-wrapper ion-overlay-wrapper", onClick: dismissOnSelect ? () => this.dismiss() : undefined }, enableArrow && h("div", { class: "popover-arrow", part: "arrow" }), h("div", { key: '71f67c60fee7a29c2883c0350f19493793527be9', class: "popover-content", part: "content" }, h("slot", { key: '8fdf91d4c5ae7db8be34bfd03f703b613c73d64f' })))));
     }
     static get is() { return "ion-popover"; }
     static get encapsulation() { return "shadow"; }
@@ -1134,7 +1130,7 @@ export class Popover {
                         }, {
                             "name": "dismissParentPopover",
                             "type": "boolean",
-                            "docs": "If `true`, dismissing this popover will also dismiss\na parent popover if this popover is nested. Defaults to `true`.\n\nThis is a no-op if the overlay has not been presented yet. If you want\nto remove an overlay from the DOM that was never presented, use the\n[remove](https://developer.mozilla.org/en-US/docs/Web/API/Element/remove) method."
+                            "docs": "If `true`, dismissing this popover will also dismiss\na parent popover if this popover is nested. Defaults to `true`."
                         }],
                     "references": {
                         "Promise": {
@@ -1158,7 +1154,7 @@ export class Popover {
                             "text": "role The role of the element that is dismissing the popover. For example, 'cancel' or 'backdrop'."
                         }, {
                             "name": "param",
-                            "text": "dismissParentPopover If `true`, dismissing this popover will also dismiss\na parent popover if this popover is nested. Defaults to `true`.\n\nThis is a no-op if the overlay has not been presented yet. If you want\nto remove an overlay from the DOM that was never presented, use the\n[remove](https://developer.mozilla.org/en-US/docs/Web/API/Element/remove) method."
+                            "text": "dismissParentPopover If `true`, dismissing this popover will also dismiss\na parent popover if this popover is nested. Defaults to `true`."
                         }]
                 }
             },