@ionic/core 7.4.3-dev.11696365694.156f41d3 → 7.4.3-dev.11699471215.1cfbc6e9

package/dist/collection/components/datetime/utils/data.js

@@ -3,7 +3,7 @@
  */
 import { isAfter, isBefore, isSameDay } from "./comparison";
 import { getLocalizedDayPeriod, removeDateTzOffset, getFormattedHour, addTimePadding, getTodayLabel, getYear, } from "./format";
-import { getNumDaysInMonth, is24Hour } from "./helpers";
+import { getNumDaysInMonth, is24Hour, getHourCycle } from "./helpers";
 import { getNextMonth, getPreviousMonth, getInternalHourValue } from "./manipulation";
 /**
  * Returns the current date as
@@ -34,8 +34,14 @@ const minutes = [
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
 ];
+// h11 hour system uses 0-11. Midnight starts at 0:00am.
+const hour11 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+// h12 hour system uses 0-12. Midnight starts at 12:00am.
 const hour12 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+// h23 hour system uses 0-23. Midnight starts at 0:00.
 const hour23 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23];
+// h24 hour system uses 1-24. Midnight starts at 24:00.
+const hour24 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 0];
 /**
  * Given a locale and a mode,
  * return an array with formatted days
@@ -104,14 +110,33 @@ export const getDaysOfMonth = (month, year, firstDayOfWeek) => {
   }
   return days;
 };
+/**
+ * Returns an array of pre-defined hour
+ * values based on the provided hourCycle.
+ */
+const getHourData = (hourCycle) => {
+  switch (hourCycle) {
+    case 'h11':
+      return hour11;
+    case 'h12':
+      return hour12;
+    case 'h23':
+      return hour23;
+    case 'h24':
+      return hour24;
+    default:
+      throw new Error(`Invalid hour cycle "${hourCycle}"`);
+  }
+};
 /**
  * Given a local, reference datetime parts and option
  * max/min bound datetime parts, calculate the acceptable
  * hour and minute values according to the bounds and locale.
  */
-export const generateTime = (refParts, hourCycle = 'h12', minParts, maxParts, hourValues, minuteValues) => {
-  const use24Hour = hourCycle === 'h23';
-  let processedHours = use24Hour ? hour23 : hour12;
+export const generateTime = (locale, refParts, hourCycle = 'h12', minParts, maxParts, hourValues, minuteValues) => {
+  const computedHourCycle = getHourCycle(locale, hourCycle);
+  const use24Hour = is24Hour(computedHourCycle);
+  let processedHours = getHourData(computedHourCycle);
   let processedMinutes = minutes;
   let isAMAllowed = true;
   let isPMAllowed = true;
@@ -443,11 +468,12 @@ export const getCombinedDateColumnData = (locale, todayParts, minParts, maxParts
   };
 };
 export const getTimeColumnsData = (locale, refParts, hourCycle, minParts, maxParts, allowedHourValues, allowedMinuteValues) => {
-  const use24Hour = is24Hour(locale, hourCycle);
-  const { hours, minutes, am, pm } = generateTime(refParts, use24Hour ? 'h23' : 'h12', minParts, maxParts, allowedHourValues, allowedMinuteValues);
+  const computedHourCycle = getHourCycle(locale, hourCycle);
+  const use24Hour = is24Hour(computedHourCycle);
+  const { hours, minutes, am, pm } = generateTime(locale, refParts, computedHourCycle, minParts, maxParts, allowedHourValues, allowedMinuteValues);
   const hoursItems = hours.map((hour) => {
     return {
-      text: getFormattedHour(hour, use24Hour),
+      text: getFormattedHour(hour, computedHourCycle),
       value: getInternalHourValue(hour, use24Hour, refParts.ampm),
     };
   });

package/dist/collection/components/datetime/utils/format.js

@@ -1,6 +1,7 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
+import { is24Hour } from "./helpers";
 import { convertDataToISO } from "./manipulation";
 const getFormattedDayPeriod = (dayPeriod) => {
   if (dayPeriod === undefined) {
@@ -8,7 +9,7 @@ const getFormattedDayPeriod = (dayPeriod) => {
   }
   return dayPeriod.toUpperCase();
 };
-export const getLocalizedTime = (locale, refParts, use24Hour) => {
+export const getLocalizedTime = (locale, refParts, hourCycle) => {
   const timeParts = {
     hour: refParts.hour,
     minute: refParts.minute,
@@ -30,7 +31,7 @@ export const getLocalizedTime = (locale, refParts, use24Hour) => {
      * We use hourCycle here instead of hour12 due to:
      * https://bugs.chromium.org/p/chromium/issues/detail?id=1347316&q=hour12&can=2
      */
-    hourCycle: use24Hour ? 'h23' : 'h12',
+    hourCycle,
     /**
      * Setting Z at the end indicates that this
      * date string is in the UTC time zone. This
@@ -69,17 +70,33 @@ export const addTimePadding = (value) => {
  * 12 hour times it ensures that
  * hour 0 is formatted as '12'.
  */
-export const getFormattedHour = (hour, use24Hour) => {
-  if (use24Hour) {
-    return addTimePadding(hour);
-  }
+export const getFormattedHour = (hour, hourCycle) => {
   /**
-   * If using 12 hour
-   * format, make sure hour
-   * 0 is formatted as '12'.
+   * Midnight for h11 starts at 0:00am
+   * Midnight for h12 starts at 12:00am
+   * Midnight for h23 starts at 00:00
+   * Midnight for h24 starts at 24:00
    */
   if (hour === 0) {
-    return '12';
+    switch (hourCycle) {
+      case 'h11':
+        return '0';
+      case 'h12':
+        return '12';
+      case 'h23':
+        return '00';
+      case 'h24':
+        return '24';
+      default:
+        throw new Error(`Invalid hour cycle "${hourCycle}"`);
+    }
+  }
+  const use24Hour = is24Hour(hourCycle);
+  /**
+   * h23 and h24 use 24 hour times.
+   */
+  if (use24Hour) {
+    return addTimePadding(hour);
   }
   return hour.toString();
 };

package/dist/collection/components/datetime/utils/helpers.js

@@ -10,13 +10,19 @@
 export const isLeapYear = (year) => {
   return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
 };
-export const is24Hour = (locale, hourCycle) => {
+/**
+ * Determines the hour cycle for a user.
+ * If the hour cycle is explicitly defined, just use that.
+ * Otherwise, we try to derive it from either the specified
+ * locale extension tags or from Intl.DateTimeFormat directly.
+ */
+export const getHourCycle = (locale, hourCycle) => {
   /**
-   * If developer has explicitly enabled h23 time
+   * If developer has explicitly enabled 24-hour time
    * then return early and do not look at the system default.
    */
   if (hourCycle !== undefined) {
-    return hourCycle === 'h23';
+    return hourCycle;
   }
   /**
    * If hourCycle was not specified, check the locale
@@ -27,7 +33,7 @@ export const is24Hour = (locale, hourCycle) => {
   const formatted = new Intl.DateTimeFormat(locale, { hour: 'numeric' });
   const options = formatted.resolvedOptions();
   if (options.hourCycle !== undefined) {
-    return options.hourCycle === 'h23';
+    return options.hourCycle;
   }
   /**
    * If hourCycle is not specified (either through lack
@@ -40,7 +46,33 @@ export const is24Hour = (locale, hourCycle) => {
   if (!hour) {
     throw new Error('Hour value not found from DateTimeFormat');
   }
-  return hour.value === '00';
+  /**
+   * Midnight for h11 starts at 0:00am
+   * Midnight for h12 starts at 12:00am
+   * Midnight for h23 starts at 00:00
+   * Midnight for h24 starts at 24:00
+   */
+  switch (hour.value) {
+    case '0':
+      return 'h11';
+    case '12':
+      return 'h12';
+    case '00':
+      return 'h23';
+    case '24':
+      return 'h24';
+    default:
+      throw new Error(`Invalid hour cycle "${hourCycle}"`);
+  }
+};
+/**
+ * Determine if the hour cycle uses a 24-hour format.
+ * Returns true for h23 and h24. Returns false otherwise.
+ * If you don't know the hourCycle, use getHourCycle above
+ * and pass the result into this function.
+ */
+export const is24Hour = (hourCycle) => {
+  return hourCycle === 'h23' || hourCycle === 'h24';
 };
 /**
  * Given a date object, returns the number

package/dist/collection/components/datetime-button/datetime-button.js

@@ -8,7 +8,7 @@ import { createColorClasses } from "../../utils/theme";
 import { getIonMode } from "../../global/ionic-global";
 import { getToday } from "../datetime/utils/data";
 import { getMonthAndYear, getMonthDayAndYear, getLocalizedDateTime, getLocalizedTime } from "../datetime/utils/format";
-import { is24Hour } from "../datetime/utils/helpers";
+import { getHourCycle } from "../datetime/utils/helpers";
 import { parseDate } from "../datetime/utils/parse";
 /**
  * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
@@ -65,13 +65,13 @@ export class DatetimeButton {
        * warning in the console.
        */
       const firstParsedDatetime = parsedDatetimes[0];
-      const use24Hour = is24Hour(locale, hourCycle);
+      const computedHourCycle = getHourCycle(locale, hourCycle);
       this.dateText = this.timeText = undefined;
       switch (datetimePresentation) {
         case 'date-time':
         case 'time-date':
           const dateText = getMonthDayAndYear(locale, firstParsedDatetime);
-          const timeText = getLocalizedTime(locale, firstParsedDatetime, use24Hour);
+          const timeText = getLocalizedTime(locale, firstParsedDatetime, computedHourCycle);
           if (preferWheel) {
             this.dateText = `${dateText} ${timeText}`;
           }
@@ -98,7 +98,7 @@ export class DatetimeButton {
           }
           break;
         case 'time':
-          this.timeText = getLocalizedTime(locale, firstParsedDatetime, use24Hour);
+          this.timeText = getLocalizedTime(locale, firstParsedDatetime, computedHourCycle);
           break;
         case 'month-year':
           this.dateText = getMonthAndYear(locale, firstParsedDatetime);

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

@@ -103,22 +103,4 @@ ion-header ion-toolbar:first-of-type {
 .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.
- */
-ion-header:not(.header-collapse-main):has(~ ion-content ion-header[collapse=condense]) {
-  opacity: 0;
 }

package/dist/collection/components/nav/nav.js

@@ -672,6 +672,7 @@ export class Nav {
       : undefined;
     const mode = getIonMode(this);
     const enteringEl = enteringView.element;
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
     const leavingEl = leavingView && leavingView.element;
     const animationOpts = Object.assign(Object.assign({ mode, showGoBack: this.canGoBackSync(enteringView), baseEl: this.el, progressCallback, animated: this.animated && config.getBoolean('animated', true), enteringEl,
       leavingEl }, opts), { animationBuilder: opts.animationBuilder || this.animation || config.get('navAnimation') });

package/dist/collection/components/router/router.js

@@ -215,12 +215,14 @@ export class Router {
     }
     const routes = readRoutes(this.el);
     const fromChain = findChainForSegments(from, routes);
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
     const beforeLeaveHook = fromChain && fromChain[fromChain.length - 1].beforeLeave;
     const canLeave = beforeLeaveHook ? await beforeLeaveHook() : true;
     if (canLeave === false || typeof canLeave === 'object') {
       return canLeave;
     }
     const toChain = findChainForSegments(to, routes);
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
     const beforeEnterHook = toChain && toChain[toChain.length - 1].beforeEnter;
     return beforeEnterHook ? beforeEnterHook() : true;
   }

package/dist/collection/components/router/utils/path.js

@@ -38,6 +38,7 @@ export const chainToSegments = (chain) => {
   for (const route of chain) {
     for (const segment of route.segments) {
       if (segment[0] === ':') {
+        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
         const param = route.params && route.params[segment.slice(1)];
         if (!param) {
           return null;

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

@@ -642,7 +642,7 @@ Developers can use the "legacy" property to continue using the legacy form marku
   }
   renderListbox() {
     const { disabled, inputId, isExpanded } = this;
-    return (h("button", { disabled: disabled, id: inputId, "aria-label": this.ariaLabel, "aria-haspopup": "listbox", "aria-expanded": `${isExpanded}`, onFocus: this.onFocus, onBlur: this.onBlur, ref: (focusEl) => (this.focusEl = focusEl) }));
+    return (h("button", { disabled: disabled, id: inputId, "aria-label": this.ariaLabel, "aria-haspopup": "dialog", "aria-expanded": `${isExpanded}`, onFocus: this.onFocus, onBlur: this.onBlur, ref: (focusEl) => (this.focusEl = focusEl) }));
   }
   render() {
     const { legacyFormController } = this;

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

@@ -6,13 +6,12 @@ import { getElementRoot } from "../../../utils/helpers";
 /**
  * iOS Toast Enter Animation
  */
-export const iosEnterAnimation = (baseEl, position) => {
+export const iosEnterAnimation = (baseEl, opts) => {
   const baseAnimation = createAnimation();
   const wrapperAnimation = createAnimation();
+  const { position, top, bottom } = opts;
   const root = getElementRoot(baseEl);
   const wrapperEl = root.querySelector('.toast-wrapper');
-  const bottom = `calc(-10px - var(--ion-safe-area-bottom, 0px))`;
-  const top = `calc(10px + var(--ion-safe-area-top, 0px))`;
   wrapperAnimation.addElement(wrapperEl);
   switch (position) {
     case 'top':

package/dist/collection/components/toast/animations/ios.leave.js

@@ -6,13 +6,12 @@ import { getElementRoot } from "../../../utils/helpers";
 /**
  * iOS Toast Leave Animation
  */
-export const iosLeaveAnimation = (baseEl, position) => {
+export const iosLeaveAnimation = (baseEl, opts) => {
   const baseAnimation = createAnimation();
   const wrapperAnimation = createAnimation();
+  const { position, top, bottom } = opts;
   const root = getElementRoot(baseEl);
   const wrapperEl = root.querySelector('.toast-wrapper');
-  const bottom = `calc(-10px - var(--ion-safe-area-bottom, 0px))`;
-  const top = `calc(10px + var(--ion-safe-area-top, 0px))`;
   wrapperAnimation.addElement(wrapperEl);
   switch (position) {
     case 'top':

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

@@ -6,13 +6,12 @@ import { getElementRoot } from "../../../utils/helpers";
 /**
  * MD Toast Enter Animation
  */
-export const mdEnterAnimation = (baseEl, position) => {
+export const mdEnterAnimation = (baseEl, opts) => {
   const baseAnimation = createAnimation();
   const wrapperAnimation = createAnimation();
+  const { position, top, bottom } = opts;
   const root = getElementRoot(baseEl);
   const wrapperEl = root.querySelector('.toast-wrapper');
-  const bottom = `calc(8px + var(--ion-safe-area-bottom, 0px))`;
-  const top = `calc(8px + var(--ion-safe-area-top, 0px))`;
   wrapperAnimation.addElement(wrapperEl);
   switch (position) {
     case 'top':

package/dist/collection/components/toast/animations/utils.js

@@ -0,0 +1,85 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { win } from "../../../utils/browser/index";
+import { printIonWarning } from "../../../utils/logging/index";
+/**
+ * Calculate the CSS top and bottom position of the toast, to be used
+ * as starting points for the animation keyframes.
+ *
+ * Note that MD animates bottom-positioned toasts using style.bottom,
+ * which calculates from the bottom edge of the screen, while iOS uses
+ * translateY, which calculates from the top edge of the screen. This
+ * is why the bottom calculates differ slightly between modes.
+ *
+ * @param position The value of the toast's position prop.
+ * @param positionAnchor The element the toast should be anchored to,
+ * if applicable.
+ * @param mode The toast component's mode (md, ios, etc).
+ * @param toast A reference to the toast element itself.
+ */
+export function getAnimationPosition(position, positionAnchor, mode, toast) {
+  /**
+   * Start with a predefined offset from the edge the toast will be
+   * positioned relative to, whether on the screen or anchor element.
+   */
+  let offset;
+  if (mode === 'md') {
+    offset = 8;
+  }
+  else {
+    offset = position === 'top' ? 10 : -10;
+  }
+  /**
+   * If positionAnchor is defined, add in the distance from the target
+   * screen edge to the target anchor edge. For position="top", the
+   * bottom anchor edge is targeted. For position="bottom", the top
+   * anchor edge is targeted.
+   */
+  if (positionAnchor && win) {
+    warnIfAnchorIsHidden(positionAnchor, toast);
+    const box = positionAnchor.getBoundingClientRect();
+    if (position === 'top') {
+      offset += box.bottom;
+    }
+    else if (position === 'bottom') {
+      /**
+       * Just box.top is the distance from the top edge of the screen
+       * to the top edge of the anchor. We want to calculate from the
+       * bottom edge of the screen instead.
+       */
+      if (mode === 'md') {
+        offset += win.innerHeight - box.top;
+      }
+      else {
+        offset -= win.innerHeight - box.top;
+      }
+    }
+    /**
+     * We don't include safe area here because that should already be
+     * accounted for when checking the position of the anchor.
+     */
+    return {
+      top: `${offset}px`,
+      bottom: `${offset}px`,
+    };
+  }
+  else {
+    return {
+      top: `calc(${offset}px + var(--ion-safe-area-top, 0px))`,
+      bottom: mode === 'md'
+        ? `calc(${offset}px + var(--ion-safe-area-bottom, 0px))`
+        : `calc(${offset}px - var(--ion-safe-area-bottom, 0px))`,
+    };
+  }
+}
+/**
+ * If the anchor element is hidden, getBoundingClientRect()
+ * will return all 0s for it, which can cause unexpected
+ * results in the position calculation when animating.
+ */
+function warnIfAnchorIsHidden(positionAnchor, toast) {
+  if (positionAnchor.offsetParent === null) {
+    printIonWarning('The positionAnchor element for ion-toast was found in the DOM, but appears to be hidden. This may lead to unexpected positioning of the toast.', toast);
+  }
+}

package/dist/collection/components/toast/test/position-anchor/toast.e2e.js

@@ -0,0 +1,45 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { expect } from "@playwright/test";
+import { configs, test } from "../../../../utils/test/playwright/index";
+configs({ directions: ['ltr'] }).forEach(({ title, screenshot, config }) => {
+  test.describe(title('toast: positionAnchor'), () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('/src/components/toast/test/position-anchor', config);
+      /**
+       * We need to screenshot the whole page to ensure the toasts are positioned
+       * correctly, but we don't need much extra white space between the header
+       * and footer.
+       */
+      await page.setViewportSize({
+        width: 425,
+        height: 425,
+      });
+    });
+    test('should place top-position toast underneath anchor', async ({ page }) => {
+      const ionToastDidPresent = await page.spyOnEvent('ionToastDidPresent');
+      await page.click('#headerAnchor');
+      await ionToastDidPresent.next();
+      await expect(page).toHaveScreenshot(screenshot(`toast-header-anchor`));
+    });
+    test('should place bottom-position toast above anchor', async ({ page }) => {
+      const ionToastDidPresent = await page.spyOnEvent('ionToastDidPresent');
+      await page.click('#footerAnchor');
+      await ionToastDidPresent.next();
+      await expect(page).toHaveScreenshot(screenshot(`toast-footer-anchor`));
+    });
+    test('should ignore anchor for middle-position toast', async ({ page }) => {
+      const ionToastDidPresent = await page.spyOnEvent('ionToastDidPresent');
+      await page.click('#middleAnchor');
+      await ionToastDidPresent.next();
+      await expect(page).toHaveScreenshot(screenshot(`toast-middle-anchor`));
+    });
+    test('should correctly anchor toast when using an element reference', async ({ page }) => {
+      const ionToastDidPresent = await page.spyOnEvent('ionToastDidPresent');
+      await page.click('#headerElAnchor');
+      await ionToastDidPresent.next();
+      await expect(page).toHaveScreenshot(screenshot(`toast-header-el-anchor`));
+    });
+  });
+});

package/dist/collection/components/toast/toast.js

@@ -15,6 +15,7 @@ import { iosEnterAnimation } from "./animations/ios.enter";
 import { iosLeaveAnimation } from "./animations/ios.leave";
 import { mdEnterAnimation } from "./animations/md.enter";
 import { mdLeaveAnimation } from "./animations/md.leave";
+import { getAnimationPosition } from "./animations/utils";
 // TODO(FW-2832): types
 /**
  * @virtualProp {"ios" | "md"} mode - The mode determines which platform styles to use.
@@ -54,6 +55,7 @@ export class Toast {
     this.message = undefined;
     this.keyboardClose = false;
     this.position = 'bottom';
+    this.positionAnchor = undefined;
     this.buttons = undefined;
     this.translucent = false;
     this.animated = true;
@@ -101,7 +103,19 @@ export class Toast {
   async present() {
     const unlock = await this.lockController.lock();
     await this.delegateController.attachViewToDom();
-    await present(this, 'toastEnter', iosEnterAnimation, mdEnterAnimation, this.position);
+    const { el, position } = this;
+    const anchor = this.getAnchorElement();
+    const animationPosition = getAnimationPosition(position, anchor, getIonMode(this), el);
+    /**
+     * Cache the calculated position of the toast, so we can re-use it
+     * in the dismiss animation.
+     */
+    this.lastPresentedPosition = animationPosition;
+    await present(this, 'toastEnter', iosEnterAnimation, mdEnterAnimation, {
+      position,
+      top: animationPosition.top,
+      bottom: animationPosition.bottom,
+    });
     /**
      * Content is revealed to screen readers after
      * the transition to avoid jank since this
@@ -123,15 +137,28 @@ export class Toast {
    * Some examples include: ``"cancel"`, `"destructive"`, "selected"`, and `"backdrop"`.
    */
   async dismiss(data, role) {
+    var _a, _b;
     const unlock = await this.lockController.lock();
-    if (this.durationTimeout) {
-      clearTimeout(this.durationTimeout);
+    const { durationTimeout, position, lastPresentedPosition } = this;
+    if (durationTimeout) {
+      clearTimeout(durationTimeout);
     }
-    const dismissed = await dismiss(this, data, role, 'toastLeave', iosLeaveAnimation, mdLeaveAnimation, this.position);
+    const dismissed = await dismiss(this, data, role, 'toastLeave', iosLeaveAnimation, mdLeaveAnimation, 
+    /**
+     * Fetch the cached position that was calculated back in the present
+     * animation. We always want to animate the dismiss from the same
+     * position the present stopped at, so the animation looks continuous.
+     */
+    {
+      position,
+      top: (_a = lastPresentedPosition === null || lastPresentedPosition === void 0 ? void 0 : lastPresentedPosition.top) !== null && _a !== void 0 ? _a : '',
+      bottom: (_b = lastPresentedPosition === null || lastPresentedPosition === void 0 ? void 0 : lastPresentedPosition.bottom) !== null && _b !== void 0 ? _b : '',
+    });
     if (dismissed) {
       this.delegateController.removeViewFromDom();
       this.revealContentToScreenReader = false;
     }
+    this.lastPresentedPosition = undefined;
     unlock();
     return dismissed;
   }
@@ -155,6 +182,37 @@ export class Toast {
       : [];
     return buttons;
   }
+  /**
+   * Returns the element specified by the positionAnchor prop,
+   * or undefined if prop's value is an ID string and the element
+   * is not found in the DOM.
+   */
+  getAnchorElement() {
+    const { position, positionAnchor, el } = this;
+    if (position === 'middle' && positionAnchor !== undefined) {
+      printIonWarning('The positionAnchor property is ignored when using position="middle".', this.el);
+      return undefined;
+    }
+    if (typeof positionAnchor === 'string') {
+      /**
+       * If the anchor is defined as an ID, find the element.
+       * We do this on every present so the toast doesn't need
+       * to account for the surrounding DOM changing since the
+       * last time it was presented.
+       */
+      const foundEl = document.getElementById(positionAnchor);
+      if (foundEl === null) {
+        printIonWarning(`An anchor element with an ID of "${positionAnchor}" was not found in the DOM.`, el);
+        return undefined;
+      }
+      return foundEl;
+    }
+    if (positionAnchor instanceof HTMLElement) {
+      return positionAnchor;
+    }
+    printIonWarning('Invalid positionAnchor value:', positionAnchor, el);
+    return undefined;
+  }
   async buttonClick(button) {
     const role = button.role;
     if (isCancel(role)) {
@@ -517,12 +575,34 @@ export class Toast {
         "optional": false,
         "docs": {
           "tags": [],
-          "text": "The position of the toast on the screen."
+          "text": "The starting position of the toast on the screen. Can be tweaked further\nusing the `positionAnchor` property."
         },
         "attribute": "position",
         "reflect": false,
         "defaultValue": "'bottom'"
       },
+      "positionAnchor": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "HTMLElement | string",
+          "resolved": "HTMLElement | string | undefined",
+          "references": {
+            "HTMLElement": {
+              "location": "global",
+              "id": "global::HTMLElement"
+            }
+          }
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": "The element to anchor the toast's position to. Can be set as a direct reference\nor the ID of the element. With `position=\"bottom\"`, the toast will sit above the\nchosen element. With `position=\"top\"`, the toast will sit below the chosen element.\nWith `position=\"middle\"`, the value of `positionAnchor` is ignored."
+        },
+        "attribute": "position-anchor",
+        "reflect": false
+      },
       "buttons": {
         "type": "unknown",
         "mutable": false,
@@ -813,8 +893,9 @@ export class Toast {
               "id": "global::Promise"
             },
             "ToastPresentOptions": {
-              "location": "global",
-              "id": "global::ToastPresentOptions"
+              "location": "import",
+              "path": "./toast-interface",
+              "id": "src/components/toast/toast-interface.ts::ToastPresentOptions"
             }
           },
           "return": "Promise<void>"
@@ -846,8 +927,9 @@ export class Toast {
               "id": "global::Promise"
             },
             "ToastDismissOptions": {
-              "location": "global",
-              "id": "global::ToastDismissOptions"
+              "location": "import",
+              "path": "./toast-interface",
+              "id": "src/components/toast/toast-interface.ts::ToastDismissOptions"
             }
           },
           "return": "Promise<boolean>"