@ionic/core 8.8.19 → 8.8.20-dev.11788449221.155f9f1e

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

@@ -1,3 +1,173 @@
+ion-header {
+  display: block;
+  position: relative;
+  order: -1;
+  width: 100%;
+}
+
+ion-header ion-toolbar:first-of-type {
+  padding-top: var(--ion-safe-area-top, 0);
+}
+
+.header-collapse-fade ion-toolbar {
+  --opacity-scale: inherit;
+}
+
+/**
+ * Override styles applied during the page transition to prevent
+ * header flickering.
+ */
+.header-collapse-fade.header-transitioning ion-toolbar {
+  --background: transparent;
+  --border-style: none;
+}
+
+.header-collapse-condense {
+  z-index: 9;
+}
+
+.header-collapse-condense ion-toolbar {
+  position: sticky;
+  top: 0;
+}
+
+.header-collapse-condense ion-toolbar:first-of-type {
+  /**
+   * The toolbar that contains the collapsible
+   * large title should not have safe area padding applied.
+   */
+  padding-top: 0px;
+  z-index: 1;
+}
+
+/**
+ * Large title toolbar should just use the content background
+ * since it needs to blend in with the header above it.
+ */
+.header-collapse-condense ion-toolbar {
+  z-index: 0;
+}
+
+.header-collapse-condense ion-toolbar:last-of-type {
+  --border-width: 0px;
+}
+
+.header-collapse-condense ion-toolbar ion-searchbar {
+  padding-top: 0px;
+  padding-bottom: 13px;
+}
+
+.header-collapse-main {
+  --opacity-scale: 1;
+}
+
+.header-collapse-main ion-toolbar {
+  --opacity-scale: inherit;
+}
+
+.header-collapse-main ion-toolbar.in-toolbar ion-title,
+.header-collapse-main ion-toolbar.in-toolbar ion-buttons {
+  transition: all 0.2s ease-in-out;
+}
+
+/**
+ * Large title toolbar should just use the content background
+ * since it needs to blend in with the header above it.
+ */
+.header-collapse-condense ion-toolbar,
+.header-collapse-condense-inactive.header-transitioning:not(.header-collapse-condense) ion-toolbar {
+  --background: var(--ion-background-color, #fff);
+}
+
+/**
+ * Override styles applied during the page transition to prevent
+ * header flickering.
+ */
+.header-collapse-condense-inactive.header-transitioning:not(.header-collapse-condense) ion-toolbar {
+  --border-style: none;
+  --opacity-scale: 1;
+}
+
+.header-collapse-condense-inactive:not(.header-collapse-condense) ion-toolbar.in-toolbar ion-title,
+.header-collapse-condense-inactive:not(.header-collapse-condense) ion-toolbar.in-toolbar ion-buttons.buttons-collapse {
+  opacity: 0;
+  pointer-events: none;
+}
+
+/**
+ * There is a bug in Safari where changing
+ * the opacity of an element in a scrollable container
+ * while rubber-banding causes the scroll position
+ * to jump to the top
+ */
+.header-collapse-condense-inactive.header-collapse-condense ion-toolbar.in-toolbar ion-title,
+.header-collapse-condense-inactive.header-collapse-condense ion-toolbar.in-toolbar ion-buttons.buttons-collapse {
+  visibility: hidden;
+}
+
+/**
+ * The main header is only hidden once the collapsible large
+ * title is configured. As a result, if the main header loads
+ * before the collapsible large title is configured then the
+ * main header will be visible briefly before being hidden
+ * by the collapsible large title.
+ *
+ * The following selector ensures that any main header
+ * on a page with a collapsible large title is hidden
+ * before the collapsible large title is configured.
+ * Once the collapsible large title is configured the main
+ * header will have the ".header-collapse-main" class, and
+ * this selector will no longer apply.
+ *
+ * The :has(...) part of the selector ensures a couple things:
+ * 1. This will only apply within a page view since the content
+ * must be a subsequent-sibling of the header (~ ion-content).
+ * 2. This will only apply when that content has an active condense
+ *    header (the .header-collapse-condense class).
+ *
+ * We use opacity: 0 to avoid a layout shift.
+ * We use the class (not the attribute) because the class is only
+ * added when the condense effect is valid (large title present).
+ * The attribute alone is not sufficient since it would match even
+ * when the effect is guarded (e.g. no large title).
+ */
+ion-header:not(.header-collapse-main):has(~ ion-content ion-header.header-collapse-condense) {
+  opacity: 0;
+}
+
+/**
+ * The deprecated collapse="condense" prop is iOS-only.
+ * On non-iOS themes, the condense header should be hidden since
+ * the JS won't activate it. Uses a class instead of an attribute
+ * selector because collapse is not a reflected prop, and framework
+ * proxies (Angular/Vue) bind it as a property.
+ */
+.header-collapse-condense-hidden {
+  display: none;
+}
+
+ion-header.header-scroll-effect-hide {
+  transition: transform 300ms cubic-bezier(0, 0, 0.2, 1), opacity 300ms cubic-bezier(0, 0, 0.2, 1);
+}
+
+ion-header.header-scroll-effect-hide.header-scroll-hidden {
+  transform: translateY(-100%);
+  transition: transform 200ms cubic-bezier(0.4, 0, 1, 1), opacity 300ms cubic-bezier(0.4, 0, 1, 1);
+  opacity: 0;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  ion-header.header-scroll-effect-hide,
+  ion-header.header-scroll-effect-hide.header-scroll-hidden {
+    transition: none;
+  }
+}
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use
@@ -54,17 +224,15 @@
  * }
  */
 ion-header {
-  display: block;
-  position: relative;
-  order: -1;
-  width: 100%;
   z-index: 10;
 }
 
-ion-header ion-toolbar:first-of-type {
-  padding-top: var(--ion-safe-area-top, 0);
-}
-
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use
@@ -124,8 +292,30 @@ ion-header ion-toolbar:first-of-type {
   box-shadow: 0 2px 4px -1px rgba(0, 0, 0, 0.2), 0 4px 5px 0 rgba(0, 0, 0, 0.14), 0 1px 10px 0 rgba(0, 0, 0, 0.12);
 }
 
+/**
+ * The condense header should blend seamlessly with the
+ * main header above it, so remove the box-shadow.
+ */
 .header-md.header-collapse-condense {
-  display: none;
+  box-shadow: none;
+}
+
+/**
+ * When the condense header is active (large title visible),
+ * the main header's box-shadow should be hidden so it blends
+ * with the condense header below it.
+ */
+.header-md.header-collapse-condense-inactive:not(.header-collapse-condense) {
+  box-shadow: none;
+}
+
+/**
+ * The fade effect fades the toolbar background via --opacity-scale,
+ * but box-shadow is not affected by that variable. Remove it so
+ * the shadow doesn't persist when the background is faded out.
+ */
+.header-md.header-collapse-fade {
+  box-shadow: none;
 }
 
 .header-md.ion-no-border {

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

@@ -50,13 +50,14 @@ export const handleContentScroll = (scrollEl, scrollHeaderIndex, contentEl) => {
     });
 };
 export const setToolbarBackgroundOpacity = (headerEl, opacity) => {
+    var _a;
     /**
      * Fading in the backdrop opacity
      * should happen after the large title
      * has collapsed, so it is handled
      * by handleHeaderFade()
      */
-    if (headerEl.collapse === 'fade') {
+    if (((_a = headerEl.scrollEffect) !== null && _a !== void 0 ? _a : headerEl.collapse) === 'fade') {
         return;
     }
     if (opacity === undefined) {
@@ -214,23 +215,15 @@ export const handleHeaderFade = (scrollEl, baseEl, condenseHeader) => {
  * Get the role type for the ion-header.
  *
  * @param isInsideMenu If ion-header is inside ion-menu.
- * @param isCondensed If ion-header has collapse="condense".
- * @param mode The current mode.
- * @returns 'none' if inside ion-menu or if condensed in md
- * mode, otherwise 'banner'.
+ * @returns 'none' if inside ion-menu, otherwise 'banner'.
+ * Condensed headers start as 'banner' and have their role
+ * toggled dynamically by setHeaderActive() on scroll.
  */
-export const getRoleType = (isInsideMenu, isCondensed, mode) => {
+export const getRoleType = (isInsideMenu) => {
     // If the header is inside a menu, it should not have the banner role.
     if (isInsideMenu) {
         return ROLE_NONE;
     }
-    /**
-     * Only apply role="none" to `md` mode condensed headers
-     * since the large header is never shown.
-     */
-    if (isCondensed && mode === 'md') {
-        return ROLE_NONE;
-    }
     // Default to banner role.
     return ROLE_BANNER;
 };

package/dist/collection/components/img/img.js

@@ -3,8 +3,11 @@
  */
 import { Host, h } from "@stencil/core";
 import { inheritAttributes } from "../../utils/helpers";
-import { getIonMode } from "../../global/ionic-global";
+import { getIonTheme } from "../../global/ionic-global";
 /**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ *
  * @part image - The inner `img` element.
  */
 export class Img {
@@ -76,7 +79,10 @@ export class Img {
     render() {
         const { loadSrc, alt, onLoad, loadError, inheritedAttributes } = this;
         const { draggable } = inheritedAttributes;
-        return (h(Host, { key: '9bfaa659b0680189fd29f3acb2fdce7f70be6060', class: getIonMode(this) }, h("img", { key: 'd484beae0d5cbe0406958bfad40cdd6c05625340', decoding: "async", src: loadSrc, alt: alt, onLoad: onLoad, onError: loadError, part: "image", draggable: isDraggable(draggable) })));
+        const theme = getIonTheme(this);
+        return (h(Host, { key: 'ba84621055567b2a35387709d9d89b97ad853274', class: {
+                [theme]: true,
+            } }, h("img", { key: '9d6118bbf69e2cccbb0603802c03b9a0d101e2c3', decoding: "async", src: loadSrc, alt: alt, onLoad: onLoad, onError: loadError, part: "image", draggable: isDraggable(draggable) })));
     }
     static get is() { return "ion-img"; }
     static get encapsulation() { return "shadow"; }

package/dist/collection/components/infinite-scroll/infinite-scroll.js

@@ -3,11 +3,16 @@
  */
 import { Host, h, readTask, writeTask } from "@stencil/core";
 import { findClosestIonContent, getScrollElement, printIonContentErrorMsg } from "../../utils/content/index";
-import { getIonMode } from "../../global/ionic-global";
+import { getIonTheme } from "../../global/ionic-global";
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ */
 export class InfiniteScroll {
     constructor() {
         this.thrPx = 0;
         this.thrPc = 0;
+        this.minHeightLocked = false;
         /**
          * didFire exists so that ionInfinite
          * does not fire multiple times if
@@ -43,6 +48,12 @@ export class InfiniteScroll {
          * The value can be either `top` or `bottom`.
          */
         this.position = 'bottom';
+        /**
+         * If `true`, the infinite scroll will preserve the scroll position
+         * when the content is re-rendered. This is useful when the content is
+         * re-rendered with new keys, and the scroll position should be preserved.
+         */
+        this.preserveRerenderScrollPosition = false;
         this.onScroll = () => {
             const scrollEl = this.scrollEl;
             if (!scrollEl || !this.canStart()) {
@@ -64,7 +75,16 @@ export class InfiniteScroll {
                 if (!this.didFire) {
                     this.isLoading = true;
                     this.didFire = true;
-                    this.ionInfinite.emit();
+                    if (this.preserveRerenderScrollPosition) {
+                        // Lock the min height of the siblings of the infinite scroll
+                        // if we are preserving the rerender scroll position
+                        this.lockSiblingMinHeight(true).then(() => {
+                            this.ionInfinite.emit();
+                        });
+                    }
+                    else {
+                        this.ionInfinite.emit();
+                    }
                     return 3;
                 }
             }
@@ -111,6 +131,54 @@ export class InfiniteScroll {
         this.enableScrollEvents(false);
         this.scrollEl = undefined;
     }
+    /**
+     * Loop through our sibling elements and lock or unlock their min height.
+     * This keeps our siblings, for example `ion-list`, the same height as their
+     * content currently is, so when it loads new data and the DOM removes the old
+     * data, the height of the container doesn't change and we don't lose our scroll position.
+     *
+     * We preserve existing min-height values, if they're set, so we don't erase what
+     * has been previously set by the user when we restore after complete is called.
+     */
+    lockSiblingMinHeight(lock) {
+        return new Promise((resolve) => {
+            var _a;
+            const siblings = ((_a = this.el.parentElement) === null || _a === void 0 ? void 0 : _a.children) || [];
+            const writes = [];
+            for (const sibling of siblings) {
+                // Loop through all the siblings of the infinite scroll, but ignore ourself
+                if (sibling !== this.el && sibling instanceof HTMLElement) {
+                    if (lock) {
+                        const elementHeight = sibling.getBoundingClientRect().height;
+                        writes.push(() => {
+                            if (this.minHeightLocked) {
+                                // The previous min height is from us locking it before, so we can disregard it
+                                // We still need to lock the min height if we're already locked, though, because
+                                // the user could have triggered a new load before we've finished the previous one.
+                                const previousMinHeight = sibling.style.minHeight;
+                                if (previousMinHeight) {
+                                    sibling.style.setProperty('--ion-previous-min-height', previousMinHeight);
+                                }
+                            }
+                            sibling.style.minHeight = `${elementHeight}px`;
+                        });
+                    }
+                    else {
+                        writes.push(() => {
+                            const previousMinHeight = sibling.style.getPropertyValue('--ion-previous-min-height');
+                            sibling.style.minHeight = previousMinHeight || 'auto';
+                            sibling.style.removeProperty('--ion-previous-min-height');
+                        });
+                    }
+                }
+            }
+            writeTask(() => {
+                writes.forEach((w) => w());
+                this.minHeightLocked = lock;
+                resolve();
+            });
+        });
+    }
     /**
      * Call `complete()` within the `ionInfinite` output event handler when
      * your async operation has completed. For example, the `loading`
@@ -172,6 +240,13 @@ export class InfiniteScroll {
         else {
             this.didFire = false;
         }
+        // Unlock the min height of the siblings of the infinite scroll
+        // if we are preserving the rerender scroll position
+        if (this.preserveRerenderScrollPosition) {
+            setTimeout(async () => {
+                await this.lockSiblingMinHeight(false);
+            }, 100);
+        }
     }
     canStart() {
         return !this.disabled && !this.isBusy && !!this.scrollEl && !this.isLoading;
@@ -187,10 +262,10 @@ export class InfiniteScroll {
         }
     }
     render() {
-        const mode = getIonMode(this);
+        const theme = getIonTheme(this);
         const disabled = this.disabled;
-        return (h(Host, { key: 'e844956795f69be33396ce4480aa7a54ad01b28c', class: {
-                [mode]: true,
+        return (h(Host, { key: 'e3a3cde079dfd6f07e565eb462765df757cbb128', class: {
+                [theme]: true,
                 'infinite-scroll-loading': this.isLoading,
                 'infinite-scroll-enabled': !disabled,
             } }));
@@ -267,6 +342,26 @@ export class InfiniteScroll {
                 "reflect": false,
                 "attribute": "position",
                 "defaultValue": "'bottom'"
+            },
+            "preserveRerenderScrollPosition": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "If `true`, the infinite scroll will preserve the scroll position\nwhen the content is re-rendered. This is useful when the content is\nre-rendered with new keys, and the scroll position should be preserved."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "preserve-rerender-scroll-position",
+                "defaultValue": "false"
             }
         };
     }

package/dist/collection/components/infinite-scroll-content/infinite-scroll-content.ios.css

@@ -1,3 +1,9 @@
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use
@@ -84,6 +90,12 @@ ion-infinite-scroll-content {
   display: block;
 }
 
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use

package/dist/collection/components/infinite-scroll-content/infinite-scroll-content.js

@@ -5,15 +5,19 @@ import { Host, h } from "@stencil/core";
 import { ENABLE_HTML_CONTENT_DEFAULT } from "../../utils/config";
 import { sanitizeDOMString } from "../../utils/sanitization/index";
 import { config } from "../../global/config";
-import { getIonMode } from "../../global/ionic-global";
+import { getIonTheme } from "../../global/ionic-global";
+/**
+ * @virtualProp {"ios" | "md"} mode - The mode determines the platform behaviors of the component.
+ * @virtualProp {"ios" | "md" | "ionic"} theme - The theme determines the visual appearance of the component.
+ */
 export class InfiniteScrollContent {
     constructor() {
         this.customHTMLEnabled = config.get('innerHTMLTemplatesEnabled', ENABLE_HTML_CONTENT_DEFAULT);
     }
     componentDidLoad() {
         if (this.loadingSpinner === undefined) {
-            const mode = getIonMode(this);
-            this.loadingSpinner = config.get('infiniteLoadingSpinner', config.get('spinner', mode === 'ios' ? 'lines' : 'crescent'));
+            const theme = getIonTheme(this);
+            this.loadingSpinner = config.get('infiniteLoadingSpinner', config.get('spinner', theme === 'ios' ? 'lines' : 'crescent'));
         }
     }
     renderLoadingText() {
@@ -24,24 +28,26 @@ export class InfiniteScrollContent {
         return h("div", { class: "infinite-loading-text" }, this.loadingText);
     }
     render() {
-        const mode = getIonMode(this);
-        return (h(Host, { key: '7c16060dcfe2a0b0fb3e2f8f4c449589a76f1baa', class: {
-                [mode]: true,
+        const theme = getIonTheme(this);
+        return (h(Host, { key: '263a27297159ced042f7552a1e14b8c6aba62fa8', class: {
+                [theme]: true,
                 // Used internally for styling
-                [`infinite-scroll-content-${mode}`]: true,
-            } }, h("div", { key: 'a94f4d8746e053dc718f97520bd7e48cb316443a', class: "infinite-loading" }, this.loadingSpinner && (h("div", { key: '10143d5d2a50a2a2bc5de1cee8e7ab51263bcf23', class: "infinite-loading-spinner" }, h("ion-spinner", { key: '8846e88191690d9c61a0b462889ed56fbfed8b0d', name: this.loadingSpinner }))), this.loadingText !== undefined && this.renderLoadingText())));
+                [`infinite-scroll-content-${theme}`]: true,
+            } }, h("div", { key: 'ee38d3c52df9dc5de186406b3087f20917a17252', class: "infinite-loading" }, this.loadingSpinner && (h("div", { key: 'e2348727f79a26f52f42641d4334a0ba9d4aa03e', class: "infinite-loading-spinner" }, h("ion-spinner", { key: '41be6f2747f3af5f46c8738e2ef56083ecd95e99', name: this.loadingSpinner }))), this.loadingText !== undefined && this.renderLoadingText())));
     }
     static get is() { return "ion-infinite-scroll-content"; }
     static get originalStyleUrls() {
         return {
             "ios": ["infinite-scroll-content.ios.scss"],
-            "md": ["infinite-scroll-content.md.scss"]
+            "md": ["infinite-scroll-content.md.scss"],
+            "ionic": ["infinite-scroll-content.md.scss"]
         };
     }
     static get styleUrls() {
         return {
             "ios": ["infinite-scroll-content.ios.css"],
-            "md": ["infinite-scroll-content.md.css"]
+            "md": ["infinite-scroll-content.md.css"],
+            "ionic": ["infinite-scroll-content.md.css"]
         };
     }
     static get properties() {

package/dist/collection/components/infinite-scroll-content/infinite-scroll-content.md.css

@@ -1,3 +1,9 @@
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use
@@ -84,6 +90,12 @@ ion-infinite-scroll-content {
   display: block;
 }
 
+/**
+ * Convert a pixels given value into rem
+ * 
+ * @param pixels - Value in pixels to be converted (i.e. px)
+ * @param context (optional) - Baseline value
+ */
 /**
  * Convert a font size to a dynamic font size.
  * Fonts that participate in Dynamic Type should use