voyager-ionic-core 7.7.2 → 8.0.0-beta.1

package/components/overlays.js

@@ -2,12 +2,88 @@
  * (C) Ionic http://ionicframework.com - MIT License
  */
 import { d as doc } from './index5.js';
+import { f as focusVisibleElement, c as componentOnReady, a as addEventListener, b as removeEventListener, g as getElementRoot } from './helpers.js';
 import { OVERLAY_BACK_BUTTON_PRIORITY, shoudUseCloseWatcher } from './hardware-back-button.js';
 import { b as getIonMode, c as config } from './ionic-global.js';
 import { C as CoreDelegate } from './framework-delegate.js';
-import { c as componentOnReady, f as focusElement, a as addEventListener, b as removeEventListener, g as getElementRoot } from './helpers.js';
+import { B as BACKDROP_NO_SCROLL } from './gesture-controller.js';
 import { p as printIonWarning } from './index6.js';
 
+/**
+ * This query string selects elements that
+ * are eligible to receive focus. We select
+ * interactive elements that meet the following
+ * criteria:
+ * 1. Element does not have a negative tabindex
+ * 2. Element does not have `hidden`
+ * 3. Element does not have `disabled` for non-Ionic components.
+ * 4. Element does not have `disabled` or `disabled="true"` for Ionic components.
+ * Note: We need this distinction because `disabled="false"` is
+ * valid usage for the disabled property on ion-button.
+ */
+const focusableQueryString = '[tabindex]:not([tabindex^="-"]):not([hidden]):not([disabled]), input:not([type=hidden]):not([tabindex^="-"]):not([hidden]):not([disabled]), textarea:not([tabindex^="-"]):not([hidden]):not([disabled]), button:not([tabindex^="-"]):not([hidden]):not([disabled]), select:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable[disabled="false"]:not([tabindex^="-"]):not([hidden])';
+/**
+ * Focuses the first descendant in a context
+ * that can receive focus. If none exists,
+ * a fallback element will be focused.
+ * This fallback is typically an ancestor
+ * container such as a menu or overlay so focus does not
+ * leave the container we are trying to trap focus in.
+ *
+ * If no fallback is specified then we focus the container itself.
+ */
+const focusFirstDescendant = (ref, fallbackElement) => {
+    const firstInput = ref.querySelector(focusableQueryString);
+    focusElementInContext(firstInput, fallbackElement !== null && fallbackElement !== void 0 ? fallbackElement : ref);
+};
+/**
+ * Focuses the last descendant in a context
+ * that can receive focus. If none exists,
+ * a fallback element will be focused.
+ * This fallback is typically an ancestor
+ * container such as a menu or overlay so focus does not
+ * leave the container we are trying to trap focus in.
+ *
+ * If no fallback is specified then we focus the container itself.
+ */
+const focusLastDescendant = (ref, fallbackElement) => {
+    const inputs = Array.from(ref.querySelectorAll(focusableQueryString));
+    const lastInput = inputs.length > 0 ? inputs[inputs.length - 1] : null;
+    focusElementInContext(lastInput, fallbackElement !== null && fallbackElement !== void 0 ? fallbackElement : ref);
+};
+/**
+ * Focuses a particular element in a context. If the element
+ * doesn't have anything focusable associated with it then
+ * a fallback element will be focused.
+ *
+ * This fallback is typically an ancestor
+ * container such as a menu or overlay so focus does not
+ * leave the container we are trying to trap focus in.
+ * This should be used instead of the focus() method
+ * on most elements because the focusable element
+ * may not be the host element.
+ *
+ * For example, if an ion-button should be focused
+ * then we should actually focus the native <button>
+ * element inside of ion-button's shadow root, not
+ * the host element itself.
+ */
+const focusElementInContext = (hostToFocus, fallbackElement) => {
+    let elementToFocus = hostToFocus;
+    const shadowRoot = hostToFocus === null || hostToFocus === void 0 ? void 0 : hostToFocus.shadowRoot;
+    if (shadowRoot) {
+        // If there are no inner focusable elements, just focus the host element.
+        elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;
+    }
+    if (elementToFocus) {
+        focusVisibleElement(elementToFocus);
+    }
+    else {
+        // Focus fallback element instead of letting focus escape
+        fallbackElement.focus();
+    }
+};
+
 let lastOverlayIndex = 0;
 let lastId = 0;
 const activeAnimations = new WeakMap();
@@ -28,7 +104,10 @@ const alertController = /*@__PURE__*/ createController('ion-alert');
 const actionSheetController = /*@__PURE__*/ createController('ion-action-sheet');
 const loadingController = /*@__PURE__*/ createController('ion-loading');
 const modalController = /*@__PURE__*/ createController('ion-modal');
-const pickerController = /*@__PURE__*/ createController('ion-picker');
+/**
+ * @deprecated Use the inline ion-picker component instead.
+ */
+const pickerController = /*@__PURE__*/ createController('ion-picker-legacy');
 const popoverController = /*@__PURE__*/ createController('ion-popover');
 const toastController = /*@__PURE__*/ createController('ion-toast');
 /**
@@ -85,45 +164,29 @@ const createOverlay = (tagName, opts) => {
     }
     return Promise.resolve();
 };
+const isOverlayHidden = (overlay) => overlay.classList.contains('overlay-hidden');
 /**
- * This query string selects elements that
- * are eligible to receive focus. We select
- * interactive elements that meet the following
- * criteria:
- * 1. Element does not have a negative tabindex
- * 2. Element does not have `hidden`
- * 3. Element does not have `disabled` for non-Ionic components.
- * 4. Element does not have `disabled` or `disabled="true"` for Ionic components.
- * Note: We need this distinction because `disabled="false"` is
- * valid usage for the disabled property on ion-button.
+ * Focuses a particular element in an overlay. If the element
+ * doesn't have anything focusable associated with it then
+ * the overlay itself will be focused.
+ * This should be used instead of the focus() method
+ * on most elements because the focusable element
+ * may not be the host element.
+ *
+ * For example, if an ion-button should be focused
+ * then we should actually focus the native <button>
+ * element inside of ion-button's shadow root, not
+ * the host element itself.
  */
-const focusableQueryString = '[tabindex]:not([tabindex^="-"]):not([hidden]):not([disabled]), input:not([type=hidden]):not([tabindex^="-"]):not([hidden]):not([disabled]), textarea:not([tabindex^="-"]):not([hidden]):not([disabled]), button:not([tabindex^="-"]):not([hidden]):not([disabled]), select:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable:not([tabindex^="-"]):not([hidden]):not([disabled]), .ion-focusable[disabled="false"]:not([tabindex^="-"]):not([hidden])';
-const focusFirstDescendant = (ref, overlay) => {
-    let firstInput = ref.querySelector(focusableQueryString);
-    const shadowRoot = firstInput === null || firstInput === void 0 ? void 0 : firstInput.shadowRoot;
+const focusElementInOverlay = (hostToFocus, overlay) => {
+    let elementToFocus = hostToFocus;
+    const shadowRoot = hostToFocus === null || hostToFocus === void 0 ? void 0 : hostToFocus.shadowRoot;
     if (shadowRoot) {
         // If there are no inner focusable elements, just focus the host element.
-        firstInput = shadowRoot.querySelector(focusableQueryString) || firstInput;
+        elementToFocus = shadowRoot.querySelector(focusableQueryString) || hostToFocus;
     }
-    if (firstInput) {
-        focusElement(firstInput);
-    }
-    else {
-        // Focus overlay instead of letting focus escape
-        overlay.focus();
-    }
-};
-const isOverlayHidden = (overlay) => overlay.classList.contains('overlay-hidden');
-const focusLastDescendant = (ref, overlay) => {
-    const inputs = Array.from(ref.querySelectorAll(focusableQueryString));
-    let lastInput = inputs.length > 0 ? inputs[inputs.length - 1] : null;
-    const shadowRoot = lastInput === null || lastInput === void 0 ? void 0 : lastInput.shadowRoot;
-    if (shadowRoot) {
-        // If there are no inner focusable elements, just focus the host element.
-        lastInput = shadowRoot.querySelector(focusableQueryString) || lastInput;
-    }
-    if (lastInput) {
-        lastInput.focus();
+    if (elementToFocus) {
+        focusVisibleElement(elementToFocus);
     }
     else {
         // Focus overlay instead of letting focus escape
@@ -138,7 +201,7 @@ const focusLastDescendant = (ref, overlay) => {
  * Should NOT include: Toast
  */
 const trapKeyboardFocus = (ev, doc) => {
-    const lastOverlay = getPresentedOverlay(doc, 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker,ion-popover');
+    const lastOverlay = getPresentedOverlay(doc, 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker-legacy,ion-popover');
     const target = ev.target;
     /**
      * If no active overlay, ignore this event.
@@ -174,6 +237,21 @@ const trapKeyboardFocus = (ev, doc) => {
          */
         if (lastOverlay === target) {
             lastOverlay.lastFocus = undefined;
+            /**
+             * Toasts can be presented from an overlay.
+             * However, focus should still be returned to
+             * the overlay when clicking a toast. Normally,
+             * focus would be returned to the last focusable
+             * descendant in the overlay which may not always be
+             * the button that the toast was presented from. In this case,
+             * the focus may be returned to an unexpected element.
+             * To account for this, we make sure to return focus to the
+             * last focused element in the overlay if focus is
+             * moved to the toast.
+             */
+        }
+        else if (target.tagName === 'ION-TOAST') {
+            focusElementInOverlay(lastOverlay.lastFocus, lastOverlay);
             /**
              * Otherwise, we must be focusing an element
              * inside of the overlay. The two possible options
@@ -245,6 +323,21 @@ const trapKeyboardFocus = (ev, doc) => {
          */
         if (lastOverlay.contains(target)) {
             lastOverlay.lastFocus = target;
+            /**
+             * Toasts can be presented from an overlay.
+             * However, focus should still be returned to
+             * the overlay when clicking a toast. Normally,
+             * focus would be returned to the last focusable
+             * descendant in the overlay which may not always be
+             * the button that the toast was presented from. In this case,
+             * the focus may be returned to an unexpected element.
+             * To account for this, we make sure to return focus to the
+             * last focused element in the overlay if focus is
+             * moved to the toast.
+             */
+        }
+        else if (target.tagName === 'ION-TOAST') {
+            focusElementInOverlay(lastOverlay.lastFocus, lastOverlay);
         }
         else {
             /**
@@ -262,7 +355,7 @@ const trapKeyboardFocus = (ev, doc) => {
              */
             const lastFocus = lastOverlay.lastFocus;
             // Focus the first element in the overlay wrapper
-            focusFirstDescendant(lastOverlay, lastOverlay);
+            focusFirstDescendant(lastOverlay);
             /**
              * If the cached last focused element is the
              * same as the active element, then we need
@@ -273,7 +366,7 @@ const trapKeyboardFocus = (ev, doc) => {
              * last focus to equal the active element.
              */
             if (lastFocus === doc.activeElement) {
-                focusLastDescendant(lastOverlay, lastOverlay);
+                focusLastDescendant(lastOverlay);
             }
             lastOverlay.lastFocus = doc.activeElement;
         }
@@ -342,7 +435,7 @@ const dismissOverlay = (doc, data, role, overlayTag, id) => {
  */
 const getOverlays = (doc, selector) => {
     if (selector === undefined) {
-        selector = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker,ion-popover,ion-toast';
+        selector = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker-legacy,ion-popover,ion-toast';
     }
     return Array.from(doc.querySelectorAll(selector)).filter((c) => c.overlayIndex > 0);
 };
@@ -408,6 +501,7 @@ const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts)
         return;
     }
     setRootAriaHidden(true);
+    document.body.classList.add(BACKDROP_NO_SCROLL);
     /**
      * Hide all other overlays from screen readers so only this one
      * can be read. Note that presenting an overlay always makes
@@ -513,12 +607,14 @@ const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnim
     if (!overlay.presented) {
         return false;
     }
+    const lastOverlay = doc !== undefined && getPresentedOverlays(doc).length === 1;
     /**
      * If this is the last visible overlay then
      * we want to re-add the root to the accessibility tree.
      */
-    if (doc !== undefined && getPresentedOverlays(doc).length === 1) {
+    if (lastOverlay) {
         setRootAriaHidden(false);
+        document.body.classList.remove(BACKDROP_NO_SCROLL);
     }
     overlay.presented = false;
     try {
@@ -763,4 +859,4 @@ const createTriggerController = () => {
     };
 };
 
-export { BACKDROP as B, GESTURE as G, OVERLAY_GESTURE_PRIORITY as O, alertController as a, actionSheetController as b, popoverController as c, createDelegateController as d, createTriggerController as e, present as f, dismiss as g, eventMethod as h, isCancel as i, prepareOverlay as j, setOverlayId as k, loadingController as l, modalController as m, focusFirstDescendant as n, getPresentedOverlay as o, pickerController as p, safeCall as s, toastController as t };
+export { BACKDROP as B, GESTURE as G, OVERLAY_GESTURE_PRIORITY as O, alertController as a, actionSheetController as b, popoverController as c, createDelegateController as d, createTriggerController as e, present as f, dismiss as g, eventMethod as h, isCancel as i, prepareOverlay as j, setOverlayId as k, loadingController as l, modalController as m, focusFirstDescendant as n, getPresentedOverlay as o, pickerController as p, focusLastDescendant as q, safeCall as s, toastController as t };

package/components/picker-column-option.js

@@ -0,0 +1,124 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { proxyCustomElement, HTMLElement, h, Host } from '@stencil/core/internal/client';
+import { d as inheritAttributes } from './helpers.js';
+import { c as createColorClasses } from './theme.js';
+import { b as getIonMode } from './ionic-global.js';
+
+const pickerColumnOptionIosCss = "button{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;width:100%;height:34px;border:0px;outline:none;background:transparent;color:inherit;font-family:var(--ion-font-family, inherit);font-size:inherit;line-height:34px;text-align:inherit;text-overflow:ellipsis;white-space:nowrap;cursor:pointer;overflow:hidden}:host(.option-disabled){opacity:0.4}:host(.option-disabled) button{cursor:default}";
+const IonPickerColumnOptionIosStyle0 = pickerColumnOptionIosCss;
+
+const pickerColumnOptionMdCss = "button{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;width:100%;height:34px;border:0px;outline:none;background:transparent;color:inherit;font-family:var(--ion-font-family, inherit);font-size:inherit;line-height:34px;text-align:inherit;text-overflow:ellipsis;white-space:nowrap;cursor:pointer;overflow:hidden}:host(.option-disabled){opacity:0.4}:host(.option-disabled) button{cursor:default}:host(.option-active){color:var(--ion-color-base)}";
+const IonPickerColumnOptionMdStyle0 = pickerColumnOptionMdCss;
+
+const PickerColumnOption = /*@__PURE__*/ proxyCustomElement(class PickerColumnOption extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.__attachShadow();
+        /**
+         * We keep track of the parent picker column
+         * so we can update the value of it when
+         * clicking an enable option.
+         */
+        this.pickerColumn = null;
+        this.ariaLabel = null;
+        this.disabled = false;
+        this.value = undefined;
+        this.color = 'primary';
+    }
+    /**
+     * The aria-label of the option has changed after the
+     * first render and needs to be updated within the component.
+     *
+     * @param ariaLbl The new aria-label value.
+     */
+    onAriaLabelChange(ariaLbl) {
+        this.ariaLabel = ariaLbl;
+    }
+    componentWillLoad() {
+        const inheritedAttributes = inheritAttributes(this.el, ['aria-label']);
+        /**
+         * The initial value of `aria-label` needs to be set for
+         * the first render.
+    
+         */
+        this.ariaLabel = inheritedAttributes['aria-label'] || null;
+    }
+    connectedCallback() {
+        this.pickerColumn = this.el.closest('ion-picker-column');
+    }
+    disconnectedCallback() {
+        this.pickerColumn = null;
+    }
+    /**
+     * The column options can load at any time
+     * so the options needs to tell the
+     * parent picker column when it is loaded
+     * so the picker column can ensure it is
+     * centered in the view.
+     *
+     * We intentionally run this for every
+     * option. If we only ran this from
+     * the selected option then if the newly
+     * loaded options were not selected then
+     * scrollActiveItemIntoView would not be called.
+     */
+    componentDidLoad() {
+        const { pickerColumn } = this;
+        if (pickerColumn !== null) {
+            pickerColumn.scrollActiveItemIntoView();
+        }
+    }
+    /**
+     * When an option is clicked, update the
+     * parent picker column value. This
+     * component will handle centering the option
+     * in the column view.
+     */
+    onClick() {
+        const { pickerColumn } = this;
+        if (pickerColumn !== null) {
+            pickerColumn.setValue(this.value);
+        }
+    }
+    render() {
+        const { color, disabled, ariaLabel } = this;
+        const mode = getIonMode(this);
+        return (h(Host, { key: '1d5358c019c01ca429ddb514b9f9b67a3c89f652', class: createColorClasses(color, {
+                [mode]: true,
+                ['option-disabled']: disabled,
+            }) }, h("button", { key: 'c86794a15b61062a886c6f5113723ccd98238e9f', tabindex: "-1", "aria-label": ariaLabel, disabled: disabled, onClick: () => this.onClick() }, h("slot", { key: 'ab7f80cacdd39b5aedf7d2cc8eddc6288093629a' }))));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "aria-label": ["onAriaLabelChange"]
+    }; }
+    static get style() { return {
+        ios: IonPickerColumnOptionIosStyle0,
+        md: IonPickerColumnOptionMdStyle0
+    }; }
+}, [33, "ion-picker-column-option", {
+        "disabled": [4],
+        "value": [8],
+        "color": [513],
+        "ariaLabel": [32]
+    }, undefined, {
+        "aria-label": ["onAriaLabelChange"]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["ion-picker-column-option"];
+    components.forEach(tagName => { switch (tagName) {
+        case "ion-picker-column-option":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, PickerColumnOption);
+            }
+            break;
+    } });
+}
+
+export { PickerColumnOption as P, defineCustomElement as d };