@ionic/core 8.7.19-dev.11772655618.1af0949f → 8.7.19-dev.11773072221.15efeed0

package/components/p-BANeLH_G.js

@@ -0,0 +1,290 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { p as proxyCustomElement, H, e as createEvent, h, d as Host } from './p-DWoUQeZ3.js';
+import { e as renderHiddenInput } from './p-D5hF6rwn.js';
+import { c as checkInvalidState } from './p-DJztqcrH.js';
+import { b as getIonMode } from './p-Bxl5etF4.js';
+
+const radioGroupIosCss = "ion-radio-group{vertical-align:top}.radio-group-top{line-height:1.5}.radio-group-top .error-text{display:none;color:var(--ion-color-danger, #c5000f)}.radio-group-top .helper-text{display:block;color:var(--ion-color-step-700, var(--ion-text-color-step-300, #4d4d4d))}.ion-touched.ion-invalid .radio-group-top .error-text{display:block}.ion-touched.ion-invalid .radio-group-top .helper-text{display:none}ion-list .radio-group-top{-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px}";
+
+const radioGroupMdCss = "ion-radio-group{vertical-align:top}.radio-group-top{line-height:1.5}.radio-group-top .error-text{display:none;color:var(--ion-color-danger, #c5000f)}.radio-group-top .helper-text{display:block;color:var(--ion-color-step-700, var(--ion-text-color-step-300, #4d4d4d))}.ion-touched.ion-invalid .radio-group-top .error-text{display:block}.ion-touched.ion-invalid .radio-group-top .helper-text{display:none}ion-list .radio-group-top{-webkit-padding-start:16px;padding-inline-start:16px;-webkit-padding-end:16px;padding-inline-end:16px}";
+
+const RadioGroup = /*@__PURE__*/ proxyCustomElement(class RadioGroup extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.ionChange = createEvent(this, "ionChange", 7);
+        this.ionValueChange = createEvent(this, "ionValueChange", 7);
+        this.inputId = `ion-rg-${radioGroupIds++}`;
+        this.helperTextId = `${this.inputId}-helper-text`;
+        this.errorTextId = `${this.inputId}-error-text`;
+        this.labelId = `${this.inputId}-lbl`;
+        /**
+         * Track validation state for proper aria-live announcements.
+         */
+        this.isInvalid = false;
+        /**
+         * If `true`, the radios can be deselected.
+         */
+        this.allowEmptySelection = false;
+        /**
+         * The name of the control, which is submitted with the form data.
+         */
+        this.name = this.inputId;
+        this.setRadioTabindex = (value) => {
+            const radios = this.getRadios();
+            // Get the first radio that is not disabled and the checked one
+            const first = radios.find((radio) => !radio.disabled);
+            const checked = radios.find((radio) => radio.value === value && !radio.disabled);
+            if (!first && !checked) {
+                return;
+            }
+            // If an enabled checked radio exists, set it to be the focusable radio
+            // otherwise we default to focus the first radio
+            const focusable = checked || first;
+            for (const radio of radios) {
+                const tabindex = radio === focusable ? 0 : -1;
+                radio.setButtonTabindex(tabindex);
+            }
+        };
+        this.onClick = (ev) => {
+            ev.preventDefault();
+            /**
+             * The Radio Group component mandates that only one radio button
+             * within the group can be selected at any given time. Since `ion-radio`
+             * is a shadow DOM component, it cannot natively perform this behavior
+             * using the `name` attribute.
+             */
+            const selectedRadio = ev.target && ev.target.closest('ion-radio');
+            /**
+             * Our current disabled prop definition causes Stencil to mark it
+             * as optional. While this is not desired, fixing this behavior
+             * in Stencil is a significant breaking change, so this effort is
+             * being de-risked in STENCIL-917. Until then, we compromise
+             * here by checking for falsy `disabled` values instead of strictly
+             * checking `disabled === false`.
+             */
+            if (selectedRadio && !selectedRadio.disabled) {
+                const currentValue = this.value;
+                const newValue = selectedRadio.value;
+                if (newValue !== currentValue) {
+                    this.value = newValue;
+                    this.emitValueChange(ev);
+                }
+                else if (this.allowEmptySelection) {
+                    this.value = undefined;
+                    this.emitValueChange(ev);
+                }
+            }
+        };
+    }
+    valueChanged(value) {
+        this.setRadioTabindex(value);
+        this.ionValueChange.emit({ value });
+    }
+    componentDidLoad() {
+        /**
+         * There's an issue when assigning a value to the radio group
+         * within the Angular primary content (rendering within the
+         * app component template). When the template is isolated to a route,
+         * the value is assigned correctly.
+         * To address this issue, we need to ensure that the watcher is
+         * called after the component has finished loading,
+         * allowing the emit to be dispatched correctly.
+         */
+        this.valueChanged(this.value);
+    }
+    async connectedCallback() {
+        // Get the list header if it exists and set the id
+        // this is used to set aria-labelledby
+        const header = this.el.querySelector('ion-list-header') || this.el.querySelector('ion-item-divider');
+        if (header) {
+            const label = (this.label = header.querySelector('ion-label'));
+            if (label) {
+                this.labelId = label.id = this.name + '-lbl';
+            }
+        }
+        // Watch for class changes to update validation state.
+        if (typeof MutationObserver !== 'undefined') {
+            this.validationObserver = new MutationObserver(() => {
+                const newIsInvalid = checkInvalidState(this.el);
+                if (this.isInvalid !== newIsInvalid) {
+                    this.isInvalid = newIsInvalid;
+                    /**
+                     * Screen readers tend to announce changes
+                     * to `aria-describedby` when the attribute
+                     * is changed during a blur event for a
+                     * native form control.
+                     * However, the announcement can be spotty
+                     * when using a non-native form control
+                     * and `forceUpdate()`.
+                     * This is due to `forceUpdate()` internally
+                     * rescheduling the DOM update to a lower
+                     * priority queue regardless if it's called
+                     * inside a Promise or not, thus causing
+                     * the screen reader to potentially miss the
+                     * change.
+                     * By using a State variable inside a Promise,
+                     * it guarantees a re-render immediately at
+                     * a higher priority.
+                     */
+                    Promise.resolve().then(() => {
+                        this.hintTextId = this.getHintTextId();
+                    });
+                }
+            });
+            this.validationObserver.observe(this.el, {
+                attributes: true,
+                attributeFilter: ['class'],
+            });
+        }
+        // Always set initial state
+        this.isInvalid = checkInvalidState(this.el);
+    }
+    componentWillLoad() {
+        this.hintTextId = this.getHintTextId();
+    }
+    disconnectedCallback() {
+        // Clean up validation observer to prevent memory leaks.
+        if (this.validationObserver) {
+            this.validationObserver.disconnect();
+            this.validationObserver = undefined;
+        }
+    }
+    getRadios() {
+        return Array.from(this.el.querySelectorAll('ion-radio'));
+    }
+    /**
+     * Emits an `ionChange` event.
+     *
+     * This API should be called for user committed changes.
+     * This API should not be used for external value changes.
+     */
+    emitValueChange(event) {
+        const { value } = this;
+        this.ionChange.emit({ value, event });
+    }
+    onKeydown(ev) {
+        // We don't want the value to automatically change/emit when the radio group is part of a select interface
+        // as this will cause the interface to close when navigating through the radio group options
+        const inSelectInterface = !!this.el.closest('ion-select-popover') || !!this.el.closest('ion-select-modal');
+        if (ev.target && !this.el.contains(ev.target)) {
+            return;
+        }
+        // Get all radios inside of the radio group and then
+        // filter out disabled radios since we need to skip those
+        const radios = this.getRadios().filter((radio) => !radio.disabled);
+        // Only move the radio if the current focus is in the radio group
+        if (ev.target && radios.includes(ev.target)) {
+            const index = radios.findIndex((radio) => radio === ev.target);
+            const current = radios[index];
+            let next;
+            // If hitting arrow down or arrow right, move to the next radio
+            // If we're on the last radio, move to the first radio
+            if (['ArrowDown', 'ArrowRight'].includes(ev.key)) {
+                next = index === radios.length - 1 ? radios[0] : radios[index + 1];
+            }
+            // If hitting arrow up or arrow left, move to the previous radio
+            // If we're on the first radio, move to the last radio
+            if (['ArrowUp', 'ArrowLeft'].includes(ev.key)) {
+                next = index === 0 ? radios[radios.length - 1] : radios[index - 1];
+            }
+            if (next && radios.includes(next)) {
+                next.setFocus(ev);
+                if (!inSelectInterface) {
+                    this.value = next.value;
+                    this.emitValueChange(ev);
+                }
+            }
+            // Update the radio group value when a user presses the
+            // space bar on top of a selected radio
+            if ([' '].includes(ev.key)) {
+                const previousValue = this.value;
+                this.value = this.allowEmptySelection && this.value !== undefined ? undefined : current.value;
+                if (previousValue !== this.value || this.allowEmptySelection) {
+                    /**
+                     * Value change should only be emitted if the value is different,
+                     * such as selecting a new radio with the space bar or if
+                     * the radio group allows for empty selection and the user
+                     * is deselecting a checked radio.
+                     */
+                    this.emitValueChange(ev);
+                }
+                // Prevent browsers from jumping
+                // to the bottom of the screen
+                ev.preventDefault();
+            }
+        }
+    }
+    /** @internal */
+    async setFocus() {
+        const radioToFocus = this.getRadios().find((r) => r.tabIndex !== -1);
+        radioToFocus === null || radioToFocus === void 0 ? void 0 : radioToFocus.setFocus();
+    }
+    /**
+     * Renders the helper text or error text values
+     */
+    renderHintText() {
+        const { helperText, errorText, helperTextId, errorTextId, isInvalid } = this;
+        const hasHintText = !!helperText || !!errorText;
+        if (!hasHintText) {
+            return;
+        }
+        return (h("div", { class: "radio-group-top" }, h("div", { id: helperTextId, class: "helper-text", "aria-live": "polite" }, !isInvalid ? helperText : null), h("div", { id: errorTextId, class: "error-text", role: "alert" }, isInvalid ? errorText : null)));
+    }
+    getHintTextId() {
+        const { helperText, errorText, helperTextId, errorTextId, isInvalid } = this;
+        if (isInvalid && errorText) {
+            return errorTextId;
+        }
+        if (helperText) {
+            return helperTextId;
+        }
+        return undefined;
+    }
+    render() {
+        const { label, labelId, el, name, value } = this;
+        const mode = getIonMode(this);
+        renderHiddenInput(true, el, name, value, false);
+        return (h(Host, { key: 'db593b3ed511e9395e3c7bfd91b787328692cd6d', role: "radiogroup", "aria-labelledby": label ? labelId : null, "aria-describedby": this.hintTextId, "aria-invalid": this.isInvalid ? 'true' : undefined, onClick: this.onClick, class: mode }, this.renderHintText(), h("slot", { key: 'd683b01c1ba34fe843c4b320bce4661a117472a5' })));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "value": ["valueChanged"]
+    }; }
+    static get style() { return {
+        ios: radioGroupIosCss,
+        md: radioGroupMdCss
+    }; }
+}, [292, "ion-radio-group", {
+        "allowEmptySelection": [4, "allow-empty-selection"],
+        "compareWith": [1, "compare-with"],
+        "name": [1],
+        "value": [1032],
+        "helperText": [1, "helper-text"],
+        "errorText": [1, "error-text"],
+        "isInvalid": [32],
+        "hintTextId": [32],
+        "setFocus": [64]
+    }, [[4, "keydown", "onKeydown"]], {
+        "value": ["valueChanged"]
+    }]);
+let radioGroupIds = 0;
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["ion-radio-group"];
+    components.forEach(tagName => { switch (tagName) {
+        case "ion-radio-group":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, RadioGroup);
+            }
+            break;
+    } });
+}
+
+export { RadioGroup as R, defineCustomElement as d };

package/components/p-BBFQmhcD.js

@@ -0,0 +1,59 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { p as proxyCustomElement, H, h, d as Host } from './p-DWoUQeZ3.js';
+import { b as getIonMode } from './p-Bxl5etF4.js';
+
+const buttonsIosCss = ".sc-ion-buttons-ios-h{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-webkit-transform:translateZ(0);transform:translateZ(0);z-index:99}.sc-ion-buttons-ios-s ion-button{--padding-top:0;--padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0}.sc-ion-buttons-ios-s ion-button{--padding-top:3px;--padding-bottom:3px;--padding-start:5px;--padding-end:5px;-webkit-margin-start:2px;margin-inline-start:2px;-webkit-margin-end:2px;margin-inline-end:2px;min-height:32px}.sc-ion-buttons-ios-s .button-has-icon-only{--padding-top:0;--padding-bottom:0}.sc-ion-buttons-ios-s ion-button:not(.button-round){--border-radius:4px}.sc-ion-buttons-ios-h.ion-color.sc-ion-buttons-ios-s .button,.ion-color .sc-ion-buttons-ios-h.sc-ion-buttons-ios-s .button{--color:initial;--border-color:initial;--background-focused:var(--ion-color-contrast)}.sc-ion-buttons-ios-h.ion-color.sc-ion-buttons-ios-s .button-solid,.ion-color .sc-ion-buttons-ios-h.sc-ion-buttons-ios-s .button-solid{--background:var(--ion-color-contrast);--background-focused:#000;--background-focused-opacity:.12;--background-activated:#000;--background-activated-opacity:.12;--background-hover:var(--ion-color-base);--background-hover-opacity:0.45;--color:var(--ion-color-base);--color-focused:var(--ion-color-base)}.sc-ion-buttons-ios-h.ion-color.sc-ion-buttons-ios-s .button-clear,.ion-color .sc-ion-buttons-ios-h.sc-ion-buttons-ios-s .button-clear{--color-activated:var(--ion-color-contrast);--color-focused:var(--ion-color-contrast)}.sc-ion-buttons-ios-h.ion-color.sc-ion-buttons-ios-s .button-outline,.ion-color .sc-ion-buttons-ios-h.sc-ion-buttons-ios-s .button-outline{--color-activated:var(--ion-color-base);--color-focused:var(--ion-color-contrast);--background-activated:var(--ion-color-contrast)}.sc-ion-buttons-ios-s .button-clear,.sc-ion-buttons-ios-s .button-outline{--background-activated:transparent;--background-focused:currentColor;--background-hover:transparent}.sc-ion-buttons-ios-s .button-solid:not(.ion-color){--background-focused:#000;--background-focused-opacity:.12;--background-activated:#000;--background-activated-opacity:.12}.sc-ion-buttons-ios-s ion-icon[slot=start]{margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;-webkit-margin-end:0.3em;margin-inline-end:0.3em;font-size:1.41em;line-height:0.67}.sc-ion-buttons-ios-s ion-icon[slot=end]{margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;-webkit-margin-start:0.4em;margin-inline-start:0.4em;font-size:1.41em;line-height:0.67}.sc-ion-buttons-ios-s ion-icon[slot=icon-only]{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;font-size:1.65em;line-height:0.67}";
+
+const buttonsMdCss = ".sc-ion-buttons-md-h{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-webkit-transform:translateZ(0);transform:translateZ(0);z-index:99}.sc-ion-buttons-md-s ion-button{--padding-top:0;--padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0}.sc-ion-buttons-md-s ion-button{--padding-top:3px;--padding-bottom:3px;--padding-start:8px;--padding-end:8px;--box-shadow:none;-webkit-margin-start:2px;margin-inline-start:2px;-webkit-margin-end:2px;margin-inline-end:2px;min-height:32px}.sc-ion-buttons-md-s .button-has-icon-only{--padding-top:0;--padding-bottom:0}.sc-ion-buttons-md-s ion-button:not(.button-round){--border-radius:2px}.sc-ion-buttons-md-h.ion-color.sc-ion-buttons-md-s .button,.ion-color .sc-ion-buttons-md-h.sc-ion-buttons-md-s .button{--color:initial;--color-focused:var(--ion-color-contrast);--color-hover:var(--ion-color-contrast);--background-activated:transparent;--background-focused:var(--ion-color-contrast);--background-hover:var(--ion-color-contrast)}.sc-ion-buttons-md-h.ion-color.sc-ion-buttons-md-s .button-solid,.ion-color .sc-ion-buttons-md-h.sc-ion-buttons-md-s .button-solid{--background:var(--ion-color-contrast);--background-activated:transparent;--background-focused:var(--ion-color-shade);--background-hover:var(--ion-color-base);--color:var(--ion-color-base);--color-focused:var(--ion-color-base);--color-hover:var(--ion-color-base)}.sc-ion-buttons-md-h.ion-color.sc-ion-buttons-md-s .button-outline,.ion-color .sc-ion-buttons-md-h.sc-ion-buttons-md-s .button-outline{--border-color:var(--ion-color-contrast)}.sc-ion-buttons-md-s .button-has-icon-only.button-clear{--padding-top:12px;--padding-end:12px;--padding-bottom:12px;--padding-start:12px;--border-radius:50%;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;width:3rem;height:3rem}.sc-ion-buttons-md-s .button{--background-hover:currentColor}.sc-ion-buttons-md-s .button-solid{--color:var(--ion-toolbar-background, var(--ion-background-color, #fff));--background:var(--ion-toolbar-color, var(--ion-text-color, #424242));--background-activated:transparent;--background-focused:currentColor}.sc-ion-buttons-md-s .button-outline{--color:initial;--background:transparent;--background-activated:transparent;--background-focused:currentColor;--background-hover:currentColor;--border-color:currentColor}.sc-ion-buttons-md-s .button-clear{--color:initial;--background:transparent;--background-activated:transparent;--background-focused:currentColor;--background-hover:currentColor}.sc-ion-buttons-md-s ion-icon[slot=start]{margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;-webkit-margin-end:0.3em;margin-inline-end:0.3em;font-size:1.4em}.sc-ion-buttons-md-s ion-icon[slot=end]{margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;-webkit-margin-start:0.4em;margin-inline-start:0.4em;font-size:1.4em}.sc-ion-buttons-md-s ion-icon[slot=icon-only]{padding-left:0;padding-right:0;padding-top:0;padding-bottom:0;margin-left:0;margin-right:0;margin-top:0;margin-bottom:0;font-size:1.8em}";
+
+const Buttons = /*@__PURE__*/ proxyCustomElement(class Buttons extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        /**
+         * If true, buttons will disappear when its
+         * parent toolbar has fully collapsed if the toolbar
+         * is not the first toolbar. If the toolbar is the
+         * first toolbar, the buttons will be hidden and will
+         * only be shown once all toolbars have fully collapsed.
+         *
+         * Only applies in `ios` mode with `collapse` set to
+         * `true` on `ion-header`.
+         *
+         * Typically used for [Collapsible Large Titles](https://ionicframework.com/docs/api/title#collapsible-large-titles)
+         */
+        this.collapse = false;
+    }
+    render() {
+        const mode = getIonMode(this);
+        return (h(Host, { key: '58c1fc5eb867d0731c63549b1ccb3ec3bbbe6e1b', class: {
+                [mode]: true,
+                ['buttons-collapse']: this.collapse,
+            } }, h("slot", { key: '0c8f95b9840c8fa0c4e50be84c5159620a3eb5c8' })));
+    }
+    static get style() { return {
+        ios: buttonsIosCss,
+        md: buttonsMdCss
+    }; }
+}, [294, "ion-buttons", {
+        "collapse": [4]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["ion-buttons"];
+    components.forEach(tagName => { switch (tagName) {
+        case "ion-buttons":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, Buttons);
+            }
+            break;
+    } });
+}
+
+export { Buttons as B, defineCustomElement as d };

package/components/p-BC-awmYt.js

@@ -0,0 +1,306 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { d as doc } from './p-ZjP4CjeZ.js';
+import { MENU_BACK_BUTTON_PRIORITY } from './p-Boi6hecl.js';
+import { f as printIonWarning } from './p-DWoUQeZ3.js';
+import { c as componentOnReady } from './p-D5hF6rwn.js';
+import { b as getIonMode } from './p-Bxl5etF4.js';
+import { c as createAnimation } from './p-CL12ApCQ.js';
+
+/**
+ * baseAnimation
+ * Base class which is extended by the various types. Each
+ * type will provide their own animations for open and close
+ * and registers itself with Menu.
+ */
+const baseAnimation = (isIos) => {
+    // https://material.io/guidelines/motion/movement.html#movement-movement-in-out-of-screen-bounds
+    // https://material.io/guidelines/motion/duration-easing.html#duration-easing-natural-easing-curves
+    /**
+     * "Apply the sharp curve to items temporarily leaving the screen that may return
+     * from the same exit point. When they return, use the deceleration curve. On mobile,
+     * this transition typically occurs over 300ms" -- MD Motion Guide
+     */
+    return createAnimation().duration(isIos ? 400 : 300);
+};
+
+/**
+ * Menu Overlay Type
+ * The menu slides over the content. The content
+ * itself, which is under the menu, does not move.
+ */
+const menuOverlayAnimation = (menu) => {
+    let closedX;
+    let openedX;
+    const width = menu.width + 8;
+    const menuAnimation = createAnimation();
+    const backdropAnimation = createAnimation();
+    if (menu.isEndSide) {
+        // right side
+        closedX = width + 'px';
+        openedX = '0px';
+    }
+    else {
+        // left side
+        closedX = -width + 'px';
+        openedX = '0px';
+    }
+    menuAnimation.addElement(menu.menuInnerEl).fromTo('transform', `translateX(${closedX})`, `translateX(${openedX})`);
+    const mode = getIonMode(menu);
+    const isIos = mode === 'ios';
+    const opacity = isIos ? 0.2 : 0.25;
+    backdropAnimation.addElement(menu.backdropEl).fromTo('opacity', 0.01, opacity);
+    return baseAnimation(isIos).addAnimation([menuAnimation, backdropAnimation]);
+};
+
+/**
+ * Menu Push Type
+ * The content slides over to reveal the menu underneath.
+ * The menu itself also slides over to reveal its bad self.
+ */
+const menuPushAnimation = (menu) => {
+    let contentOpenedX;
+    let menuClosedX;
+    const mode = getIonMode(menu);
+    const width = menu.width;
+    if (menu.isEndSide) {
+        contentOpenedX = -width + 'px';
+        menuClosedX = width + 'px';
+    }
+    else {
+        contentOpenedX = width + 'px';
+        menuClosedX = -width + 'px';
+    }
+    const menuAnimation = createAnimation()
+        .addElement(menu.menuInnerEl)
+        .fromTo('transform', `translateX(${menuClosedX})`, 'translateX(0px)');
+    const contentAnimation = createAnimation()
+        .addElement(menu.contentEl)
+        .fromTo('transform', 'translateX(0px)', `translateX(${contentOpenedX})`);
+    const backdropAnimation = createAnimation().addElement(menu.backdropEl).fromTo('opacity', 0.01, 0.32);
+    return baseAnimation(mode === 'ios').addAnimation([menuAnimation, contentAnimation, backdropAnimation]);
+};
+
+/**
+ * Menu Reveal Type
+ * The content slides over to reveal the menu underneath.
+ * The menu itself, which is under the content, does not move.
+ */
+const menuRevealAnimation = (menu) => {
+    const mode = getIonMode(menu);
+    const openedX = menu.width * (menu.isEndSide ? -1 : 1) + 'px';
+    const contentOpen = createAnimation()
+        .addElement(menu.contentEl) // REVIEW
+        .fromTo('transform', 'translateX(0px)', `translateX(${openedX})`);
+    return baseAnimation(mode === 'ios').addAnimation(contentOpen);
+};
+
+const createMenuController = () => {
+    const menuAnimations = new Map();
+    const menus = [];
+    const open = async (menu) => {
+        const menuEl = await get(menu, true);
+        if (menuEl) {
+            return menuEl.open();
+        }
+        return false;
+    };
+    const close = async (menu) => {
+        const menuEl = await (menu !== undefined ? get(menu, true) : getOpen());
+        if (menuEl !== undefined) {
+            return menuEl.close();
+        }
+        return false;
+    };
+    const toggle = async (menu) => {
+        const menuEl = await get(menu, true);
+        if (menuEl) {
+            return menuEl.toggle();
+        }
+        return false;
+    };
+    const enable = async (shouldEnable, menu) => {
+        const menuEl = await get(menu);
+        if (menuEl) {
+            menuEl.disabled = !shouldEnable;
+        }
+        return menuEl;
+    };
+    const swipeGesture = async (shouldEnable, menu) => {
+        const menuEl = await get(menu);
+        if (menuEl) {
+            menuEl.swipeGesture = shouldEnable;
+        }
+        return menuEl;
+    };
+    const isOpen = async (menu) => {
+        if (menu != null) {
+            const menuEl = await get(menu);
+            // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+            return menuEl !== undefined && menuEl.isOpen();
+        }
+        else {
+            const menuEl = await getOpen();
+            return menuEl !== undefined;
+        }
+    };
+    const isEnabled = async (menu) => {
+        const menuEl = await get(menu);
+        if (menuEl) {
+            return !menuEl.disabled;
+        }
+        return false;
+    };
+    /**
+     * Finds and returns the menu specified by "menu" if registered.
+     * @param menu - The side or ID of the desired menu
+     * @param logOnMultipleSideMenus - If true, this function will log a warning
+     * if "menu" is a side but multiple menus on the same side were found. Since this function
+     * is used in multiple places, we default this log to false so that the calling
+     * functions can choose whether or not it is appropriate to log this warning.
+     */
+    const get = async (menu, logOnMultipleSideMenus = false) => {
+        await waitUntilReady();
+        if (menu === 'start' || menu === 'end') {
+            // there could be more than one menu on the same side
+            // so first try to get the enabled one
+            const menuRefs = menus.filter((m) => m.side === menu && !m.disabled);
+            if (menuRefs.length >= 1) {
+                if (menuRefs.length > 1 && logOnMultipleSideMenus) {
+                    printIonWarning(`menuController queried for a menu on the "${menu}" side, but ${menuRefs.length} menus were found. The first menu reference will be used. If this is not the behavior you want then pass the ID of the menu instead of its side.`, menuRefs.map((m) => m.el));
+                }
+                return menuRefs[0].el;
+            }
+            // didn't find a menu side that is enabled
+            // so try to get the first menu side found
+            const sideMenuRefs = menus.filter((m) => m.side === menu);
+            if (sideMenuRefs.length >= 1) {
+                if (sideMenuRefs.length > 1 && logOnMultipleSideMenus) {
+                    printIonWarning(`menuController queried for a menu on the "${menu}" side, but ${sideMenuRefs.length} menus were found. The first menu reference will be used. If this is not the behavior you want then pass the ID of the menu instead of its side.`, sideMenuRefs.map((m) => m.el));
+                }
+                return sideMenuRefs[0].el;
+            }
+        }
+        else if (menu != null) {
+            // the menuId was not left or right
+            // so try to get the menu by its "id"
+            return find((m) => m.menuId === menu);
+        }
+        // return the first enabled menu
+        const menuEl = find((m) => !m.disabled);
+        if (menuEl) {
+            return menuEl;
+        }
+        // get the first menu in the array, if one exists
+        return menus.length > 0 ? menus[0].el : undefined;
+    };
+    /**
+     * Get the instance of the opened menu. Returns `null` if a menu is not found.
+     */
+    const getOpen = async () => {
+        await waitUntilReady();
+        return _getOpenSync();
+    };
+    /**
+     * Get all menu instances.
+     */
+    const getMenus = async () => {
+        await waitUntilReady();
+        return getMenusSync();
+    };
+    /**
+     * Get whether or not a menu is animating. Returns `true` if any
+     * menu is currently animating.
+     */
+    const isAnimating = async () => {
+        await waitUntilReady();
+        return isAnimatingSync();
+    };
+    const registerAnimation = (name, animation) => {
+        menuAnimations.set(name, animation);
+    };
+    const _register = (menu) => {
+        if (menus.indexOf(menu) < 0) {
+            menus.push(menu);
+        }
+    };
+    const _unregister = (menu) => {
+        const index = menus.indexOf(menu);
+        if (index > -1) {
+            menus.splice(index, 1);
+        }
+    };
+    const _setOpen = async (menu, shouldOpen, animated, role) => {
+        if (isAnimatingSync()) {
+            return false;
+        }
+        if (shouldOpen) {
+            const openedMenu = await getOpen();
+            if (openedMenu && menu.el !== openedMenu) {
+                await openedMenu.setOpen(false, false);
+            }
+        }
+        return menu._setOpen(shouldOpen, animated, role);
+    };
+    const _createAnimation = (type, menuCmp) => {
+        const animationBuilder = menuAnimations.get(type); // TODO(FW-2832): type
+        if (!animationBuilder) {
+            throw new Error('animation not registered');
+        }
+        const animation = animationBuilder(menuCmp);
+        return animation;
+    };
+    const _getOpenSync = () => {
+        return find((m) => m._isOpen);
+    };
+    const getMenusSync = () => {
+        return menus.map((menu) => menu.el);
+    };
+    const isAnimatingSync = () => {
+        return menus.some((menu) => menu.isAnimating);
+    };
+    const find = (predicate) => {
+        const instance = menus.find(predicate);
+        if (instance !== undefined) {
+            return instance.el;
+        }
+        return undefined;
+    };
+    const waitUntilReady = () => {
+        return Promise.all(Array.from(document.querySelectorAll('ion-menu')).map((menu) => new Promise((resolve) => componentOnReady(menu, resolve))));
+    };
+    registerAnimation('reveal', menuRevealAnimation);
+    registerAnimation('push', menuPushAnimation);
+    registerAnimation('overlay', menuOverlayAnimation);
+    doc === null || doc === void 0 ? void 0 : doc.addEventListener('ionBackButton', (ev) => {
+        const openMenu = _getOpenSync();
+        if (openMenu) {
+            ev.detail.register(MENU_BACK_BUTTON_PRIORITY, () => {
+                return openMenu.close();
+            });
+        }
+    });
+    return {
+        registerAnimation,
+        get,
+        getMenus,
+        getOpen,
+        isEnabled,
+        swipeGesture,
+        isAnimating,
+        isOpen,
+        enable,
+        toggle,
+        close,
+        open,
+        _getOpenSync,
+        _createAnimation,
+        _register,
+        _unregister,
+        _setOpen,
+    };
+};
+const menuController = /*@__PURE__*/ createMenuController();
+
+export { menuController as m };