@ionic/core 8.5.4-dev.11743804857.1f3f3ee1 → 8.5.4-dev.11743808789.130d15f2

package/dist/esm/keyboard-52278bd7.js

@@ -1,146 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { K as Keyboard } from './keyboard-73175e24.js';
-import './capacitor-59395cbd.js';
-import './index-a5d50daf.js';
-
-const KEYBOARD_DID_OPEN = 'ionKeyboardDidShow';
-const KEYBOARD_DID_CLOSE = 'ionKeyboardDidHide';
-const KEYBOARD_THRESHOLD = 150;
-// TODO(FW-2832): types
-let previousVisualViewport = {};
-let currentVisualViewport = {};
-let keyboardOpen = false;
-/**
- * This is only used for tests
- */
-const resetKeyboardAssist = () => {
-    previousVisualViewport = {};
-    currentVisualViewport = {};
-    keyboardOpen = false;
-};
-const startKeyboardAssist = (win) => {
-    const nativeEngine = Keyboard.getEngine();
-    /**
-     * If the native keyboard plugin is available
-     * then we are running in a native environment. As a result
-     * we should only listen on the native events instead of
-     * using the Visual Viewport as the Ionic webview manipulates
-     * how it resizes such that the Visual Viewport API is not
-     * reliable here.
-     */
-    if (nativeEngine) {
-        startNativeListeners(win);
-    }
-    else {
-        if (!win.visualViewport) {
-            return;
-        }
-        currentVisualViewport = copyVisualViewport(win.visualViewport);
-        win.visualViewport.onresize = () => {
-            trackViewportChanges(win);
-            if (keyboardDidOpen() || keyboardDidResize(win)) {
-                setKeyboardOpen(win);
-            }
-            else if (keyboardDidClose(win)) {
-                setKeyboardClose(win);
-            }
-        };
-    }
-};
-/**
- * Listen for events fired by native keyboard plugin
- * in Capacitor/Cordova so devs only need to listen
- * in one place.
- */
-const startNativeListeners = (win) => {
-    win.addEventListener('keyboardDidShow', (ev) => setKeyboardOpen(win, ev));
-    win.addEventListener('keyboardDidHide', () => setKeyboardClose(win));
-};
-const setKeyboardOpen = (win, ev) => {
-    fireKeyboardOpenEvent(win, ev);
-    keyboardOpen = true;
-};
-const setKeyboardClose = (win) => {
-    fireKeyboardCloseEvent(win);
-    keyboardOpen = false;
-};
-/**
- * Returns `true` if the `keyboardOpen` flag is not
- * set, the previous visual viewport width equal the current
- * visual viewport width, and if the scaled difference
- * of the previous visual viewport height minus the current
- * visual viewport height is greater than KEYBOARD_THRESHOLD
- *
- * We need to be able to accommodate users who have zooming
- * enabled in their browser (or have zoomed in manually) which
- * is why we take into account the current visual viewport's
- * scale value.
- */
-const keyboardDidOpen = () => {
-    const scaledHeightDifference = (previousVisualViewport.height - currentVisualViewport.height) * currentVisualViewport.scale;
-    return (!keyboardOpen &&
-        previousVisualViewport.width === currentVisualViewport.width &&
-        scaledHeightDifference > KEYBOARD_THRESHOLD);
-};
-/**
- * Returns `true` if the keyboard is open,
- * but the keyboard did not close
- */
-const keyboardDidResize = (win) => {
-    return keyboardOpen && !keyboardDidClose(win);
-};
-/**
- * Determine if the keyboard was closed
- * Returns `true` if the `keyboardOpen` flag is set and
- * the current visual viewport height equals the
- * layout viewport height.
- */
-const keyboardDidClose = (win) => {
-    return keyboardOpen && currentVisualViewport.height === win.innerHeight;
-};
-/**
- * Dispatch a keyboard open event
- */
-const fireKeyboardOpenEvent = (win, nativeEv) => {
-    const keyboardHeight = nativeEv ? nativeEv.keyboardHeight : win.innerHeight - currentVisualViewport.height;
-    const ev = new CustomEvent(KEYBOARD_DID_OPEN, {
-        detail: { keyboardHeight },
-    });
-    win.dispatchEvent(ev);
-};
-/**
- * Dispatch a keyboard close event
- */
-const fireKeyboardCloseEvent = (win) => {
-    const ev = new CustomEvent(KEYBOARD_DID_CLOSE);
-    win.dispatchEvent(ev);
-};
-/**
- * Given a window object, create a copy of
- * the current visual and layout viewport states
- * while also preserving the previous visual and
- * layout viewport states
- */
-const trackViewportChanges = (win) => {
-    previousVisualViewport = Object.assign({}, currentVisualViewport);
-    currentVisualViewport = copyVisualViewport(win.visualViewport);
-};
-/**
- * Creates a deep copy of the visual viewport
- * at a given state
- */
-const copyVisualViewport = (visualViewport) => {
-    return {
-        width: Math.round(visualViewport.width),
-        height: Math.round(visualViewport.height),
-        offsetTop: visualViewport.offsetTop,
-        offsetLeft: visualViewport.offsetLeft,
-        pageTop: visualViewport.pageTop,
-        pageLeft: visualViewport.pageLeft,
-        scale: visualViewport.scale,
-    };
-};
-
-export { KEYBOARD_DID_CLOSE, KEYBOARD_DID_OPEN, copyVisualViewport, keyboardDidClose, keyboardDidOpen, keyboardDidResize, resetKeyboardAssist, setKeyboardClose, setKeyboardOpen, startKeyboardAssist, trackViewportChanges };

package/dist/esm/keyboard-73175e24.js

@@ -1,79 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { g as getCapacitor } from './capacitor-59395cbd.js';
-
-var ExceptionCode;
-(function (ExceptionCode) {
-    /**
-     * API is not implemented.
-     *
-     * This usually means the API can't be used because it is not implemented for
-     * the current platform.
-     */
-    ExceptionCode["Unimplemented"] = "UNIMPLEMENTED";
-    /**
-     * API is not available.
-     *
-     * This means the API can't be used right now because:
-     *   - it is currently missing a prerequisite, such as network connectivity
-     *   - it requires a particular platform or browser version
-     */
-    ExceptionCode["Unavailable"] = "UNAVAILABLE";
-})(ExceptionCode || (ExceptionCode = {}));
-
-var KeyboardResize;
-(function (KeyboardResize) {
-    /**
-     * Only the `body` HTML element will be resized.
-     * Relative units are not affected, because the viewport does not change.
-     *
-     * @since 1.0.0
-     */
-    KeyboardResize["Body"] = "body";
-    /**
-     * Only the `ion-app` HTML element will be resized.
-     * Use it only for Ionic Framework apps.
-     *
-     * @since 1.0.0
-     */
-    KeyboardResize["Ionic"] = "ionic";
-    /**
-     * The whole native Web View will be resized when the keyboard shows/hides.
-     * This affects the `vh` relative unit.
-     *
-     * @since 1.0.0
-     */
-    KeyboardResize["Native"] = "native";
-    /**
-     * Neither the app nor the Web View are resized.
-     *
-     * @since 1.0.0
-     */
-    KeyboardResize["None"] = "none";
-})(KeyboardResize || (KeyboardResize = {}));
-const Keyboard = {
-    getEngine() {
-        const capacitor = getCapacitor();
-        if (capacitor === null || capacitor === void 0 ? void 0 : capacitor.isPluginAvailable('Keyboard')) {
-            return capacitor.Plugins.Keyboard;
-        }
-        return undefined;
-    },
-    getResizeMode() {
-        const engine = this.getEngine();
-        if (!(engine === null || engine === void 0 ? void 0 : engine.getResizeMode)) {
-            return Promise.resolve(undefined);
-        }
-        return engine.getResizeMode().catch((e) => {
-            if (e.code === ExceptionCode.Unimplemented) {
-                // If the native implementation is not available
-                // we treat it the same as if the plugin is not available.
-                return undefined;
-            }
-            throw e;
-        });
-    },
-};
-
-export { Keyboard as K, KeyboardResize as a };

package/dist/esm/keyboard-controller-ec5c2bfa.js

@@ -1,165 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { w as win, d as doc } from './index-a5d50daf.js';
-import { K as Keyboard, a as KeyboardResize } from './keyboard-73175e24.js';
-
-/**
- * The element that resizes when the keyboard opens
- * is going to depend on the resize mode
- * which is why we check that here.
- */
-const getResizeContainer = (resizeMode) => {
-    /**
-     * If doc is undefined then we are
-     * in an SSR environment, so the keyboard
-     * adjustment does not apply.
-     * If the webview does not resize then there
-     * is no container to resize.
-     */
-    if (doc === undefined || resizeMode === KeyboardResize.None || resizeMode === undefined) {
-        return null;
-    }
-    /**
-     * The three remaining resize modes: Native, Ionic, and Body
-     * all cause `ion-app` to resize, so we can listen for changes
-     * on that. In the event `ion-app` is not available then
-     * we can fall back to `body`.
-     */
-    const ionApp = doc.querySelector('ion-app');
-    return ionApp !== null && ionApp !== void 0 ? ionApp : doc.body;
-};
-/**
- * Get the height of ion-app or body.
- * This is used for determining if the webview
- * has resized before the keyboard closed.
- * */
-const getResizeContainerHeight = (resizeMode) => {
-    const containerElement = getResizeContainer(resizeMode);
-    return containerElement === null ? 0 : containerElement.clientHeight;
-};
-/**
- * Creates a controller that tracks and reacts to opening or closing the keyboard.
- *
- * @internal
- * @param keyboardChangeCallback A function to call when the keyboard opens or closes.
- */
-const createKeyboardController = async (keyboardChangeCallback) => {
-    let keyboardWillShowHandler;
-    let keyboardWillHideHandler;
-    let keyboardVisible;
-    /**
-     * This lets us determine if the webview content
-     * has resized as a result of the keyboard.
-     */
-    let initialResizeContainerHeight;
-    const init = async () => {
-        const resizeOptions = await Keyboard.getResizeMode();
-        const resizeMode = resizeOptions === undefined ? undefined : resizeOptions.mode;
-        keyboardWillShowHandler = () => {
-            /**
-             * We need to compute initialResizeContainerHeight right before
-             * the keyboard opens to guarantee the resize container is visible.
-             * The resize container may not be visible if we compute this
-             * as soon as the keyboard controller is created.
-             * We should only need to do this once to avoid additional clientHeight
-             * computations.
-             */
-            if (initialResizeContainerHeight === undefined) {
-                initialResizeContainerHeight = getResizeContainerHeight(resizeMode);
-            }
-            keyboardVisible = true;
-            fireChangeCallback(keyboardVisible, resizeMode);
-        };
-        keyboardWillHideHandler = () => {
-            keyboardVisible = false;
-            fireChangeCallback(keyboardVisible, resizeMode);
-        };
-        win === null || win === void 0 ? void 0 : win.addEventListener('keyboardWillShow', keyboardWillShowHandler);
-        win === null || win === void 0 ? void 0 : win.addEventListener('keyboardWillHide', keyboardWillHideHandler);
-    };
-    const fireChangeCallback = (state, resizeMode) => {
-        if (keyboardChangeCallback) {
-            keyboardChangeCallback(state, createResizePromiseIfNeeded(resizeMode));
-        }
-    };
-    /**
-     * Code responding to keyboard lifecycles may need
-     * to show/hide content once the webview has
-     * resized as a result of the keyboard showing/hiding.
-     * createResizePromiseIfNeeded provides a way for code to wait for the
-     * resize event that was triggered as a result of the keyboard.
-     */
-    const createResizePromiseIfNeeded = (resizeMode) => {
-        if (
-        /**
-         * If we are in an SSR environment then there is
-         * no window to resize. Additionally, if there
-         * is no resize mode or the resize mode is "None"
-         * then initialResizeContainerHeight will be 0
-         */
-        initialResizeContainerHeight === 0 ||
-            /**
-             * If the keyboard is closed before the webview resizes initially
-             * then the webview will never resize.
-             */
-            initialResizeContainerHeight === getResizeContainerHeight(resizeMode)) {
-            return;
-        }
-        /**
-         * Get the resize container so we can
-         * attach the ResizeObserver below to
-         * the correct element.
-         */
-        const containerElement = getResizeContainer(resizeMode);
-        if (containerElement === null) {
-            return;
-        }
-        /**
-         * Some part of the web content should resize,
-         * and we need to listen for a resize.
-         */
-        return new Promise((resolve) => {
-            const callback = () => {
-                /**
-                 * As per the spec, the ResizeObserver
-                 * will fire when observation starts if
-                 * the observed element is rendered and does not
-                 * have a size of 0 x 0. However, the watched element
-                 * may or may not have resized by the time this first
-                 * callback is fired. As a result, we need to check
-                 * the dimensions of the element.
-                 *
-                 * https://www.w3.org/TR/resize-observer/#intro
-                 */
-                if (containerElement.clientHeight === initialResizeContainerHeight) {
-                    /**
-                     * The resize happened, so stop listening
-                     * for resize on this element.
-                     */
-                    ro.disconnect();
-                    resolve();
-                }
-            };
-            /**
-             * In Capacitor there can be delay between when the window
-             * resizes and when the container element resizes, so we cannot
-             * rely on a 'resize' event listener on the window.
-             * Instead, we need to determine when the container
-             * element resizes using a ResizeObserver.
-             */
-            const ro = new ResizeObserver(callback);
-            ro.observe(containerElement);
-        });
-    };
-    const destroy = () => {
-        win === null || win === void 0 ? void 0 : win.removeEventListener('keyboardWillShow', keyboardWillShowHandler);
-        win === null || win === void 0 ? void 0 : win.removeEventListener('keyboardWillHide', keyboardWillHideHandler);
-        keyboardWillShowHandler = keyboardWillHideHandler = undefined;
-    };
-    const isKeyboardVisible = () => keyboardVisible;
-    await init();
-    return { init, destroy, isKeyboardVisible };
-};
-
-export { createKeyboardController as c };

package/dist/esm/lock-controller-316928be.js

@@ -1,38 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-/**
- * Creates a lock controller.
- *
- * Claiming a lock means that nothing else can acquire the lock until it is released.
- * This can momentarily prevent execution of code that needs to wait for the earlier code to finish.
- * For example, this can be used to prevent multiple transitions from occurring at the same time.
- */
-const createLockController = () => {
-    let waitPromise;
-    /**
-     * When lock() is called, the lock is claimed.
-     * Once a lock has been claimed, it cannot be claimed again until it is released.
-     * When this function gets resolved, the lock is released, allowing it to be claimed again.
-     *
-     * @example ```tsx
-     * const unlock = await this.lockController.lock();
-     * // do other stuff
-     * unlock();
-     * ```
-     */
-    const lock = async () => {
-        const p = waitPromise;
-        let resolve;
-        waitPromise = new Promise((r) => (resolve = r));
-        if (p !== undefined) {
-            await p;
-        }
-        return resolve;
-    };
-    return {
-        lock,
-    };
-};
-
-export { createLockController as c };

package/dist/esm/md.transition-8dc58b46.js

@@ -1,59 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { c as createAnimation } from './animation-eab5a4ca.js';
-import { g as getIonPageElement } from './index-ecb55b8d.js';
-import './index-a5d50daf.js';
-import './ionic-global-ca86cf32.js';
-import './index-527b9e34.js';
-import './index-738d7504.js';
-import './helpers-78efeec3.js';
-
-const mdTransitionAnimation = (_, opts) => {
-    var _a, _b, _c;
-    const OFF_BOTTOM = '40px';
-    const CENTER = '0px';
-    const backDirection = opts.direction === 'back';
-    const enteringEl = opts.enteringEl;
-    const leavingEl = opts.leavingEl;
-    const ionPageElement = getIonPageElement(enteringEl);
-    const enteringToolbarEle = ionPageElement.querySelector('ion-toolbar');
-    const rootTransition = createAnimation();
-    rootTransition.addElement(ionPageElement).fill('both').beforeRemoveClass('ion-page-invisible');
-    // animate the component itself
-    if (backDirection) {
-        rootTransition.duration(((_a = opts.duration) !== null && _a !== void 0 ? _a : 0) || 200).easing('cubic-bezier(0.47,0,0.745,0.715)');
-    }
-    else {
-        rootTransition
-            .duration(((_b = opts.duration) !== null && _b !== void 0 ? _b : 0) || 280)
-            .easing('cubic-bezier(0.36,0.66,0.04,1)')
-            .fromTo('transform', `translateY(${OFF_BOTTOM})`, `translateY(${CENTER})`)
-            .fromTo('opacity', 0.01, 1);
-    }
-    // Animate toolbar if it's there
-    if (enteringToolbarEle) {
-        const enteringToolBar = createAnimation();
-        enteringToolBar.addElement(enteringToolbarEle);
-        rootTransition.addAnimation(enteringToolBar);
-    }
-    // setup leaving view
-    if (leavingEl && backDirection) {
-        // leaving content
-        rootTransition.duration(((_c = opts.duration) !== null && _c !== void 0 ? _c : 0) || 200).easing('cubic-bezier(0.47,0,0.745,0.715)');
-        const leavingPage = createAnimation();
-        leavingPage
-            .addElement(getIonPageElement(leavingEl))
-            .onFinish((currentStep) => {
-            if (currentStep === 1 && leavingPage.elements.length > 0) {
-                leavingPage.elements[0].style.setProperty('display', 'none');
-            }
-        })
-            .fromTo('transform', `translateY(${CENTER})`, `translateY(${OFF_BOTTOM})`)
-            .fromTo('opacity', 1, 0);
-        rootTransition.addAnimation(leavingPage);
-    }
-    return rootTransition;
-};
-
-export { mdTransitionAnimation };

package/dist/esm/notch-controller-00d92e89.js

@@ -1,153 +0,0 @@
-/*!
- * (C) Ionic http://ionicframework.com - MIT License
- */
-import { w as win } from './index-a5d50daf.js';
-import { r as raf } from './helpers-78efeec3.js';
-
-/**
- * A utility to calculate the size of an outline notch
- * width relative to the content passed. This is used in
- * components such as `ion-select` with `fill="outline"`
- * where we need to pass slotted HTML content. This is not
- * needed when rendering plaintext content because we can
- * render the plaintext again hidden with `opacity: 0` inside
- * of the notch. As a result we can rely on the intrinsic size
- * of the element to correctly compute the notch width. We
- * cannot do this with slotted content because we cannot project
- * it into 2 places at once.
- *
- * @internal
- * @param el: The host element
- * @param getNotchSpacerEl: A function that returns a reference to the notch spacer element inside of the component template.
- * @param getLabelSlot: A function that returns a reference to the slotted content.
- */
-const createNotchController = (el, getNotchSpacerEl, getLabelSlot) => {
-    let notchVisibilityIO;
-    const needsExplicitNotchWidth = () => {
-        const notchSpacerEl = getNotchSpacerEl();
-        if (
-        /**
-         * If the notch is not being used
-         * then we do not need to set the notch width.
-         */
-        notchSpacerEl === undefined ||
-            /**
-             * If either the label property is being
-             * used or the label slot is not defined,
-             * then we do not need to estimate the notch width.
-             */
-            el.label !== undefined ||
-            getLabelSlot() === null) {
-            return false;
-        }
-        return true;
-    };
-    const calculateNotchWidth = () => {
-        if (needsExplicitNotchWidth()) {
-            /**
-             * Run this the frame after
-             * the browser has re-painted the host element.
-             * Otherwise, the label element may have a width
-             * of 0 and the IntersectionObserver will be used.
-             */
-            raf(() => {
-                setNotchWidth();
-            });
-        }
-    };
-    /**
-     * When using a label prop we can render
-     * the label value inside of the notch and
-     * let the browser calculate the size of the notch.
-     * However, we cannot render the label slot in multiple
-     * places so we need to manually calculate the notch dimension
-     * based on the size of the slotted content.
-     *
-     * This function should only be used to set the notch width
-     * on slotted label content. The notch width for label prop
-     * content is automatically calculated based on the
-     * intrinsic size of the label text.
-     */
-    const setNotchWidth = () => {
-        const notchSpacerEl = getNotchSpacerEl();
-        if (notchSpacerEl === undefined) {
-            return;
-        }
-        if (!needsExplicitNotchWidth()) {
-            notchSpacerEl.style.removeProperty('width');
-            return;
-        }
-        const width = getLabelSlot().scrollWidth;
-        if (
-        /**
-         * If the computed width of the label is 0
-         * and notchSpacerEl's offsetParent is null
-         * then that means the element is hidden.
-         * As a result, we need to wait for the element
-         * to become visible before setting the notch width.
-         *
-         * We do not check el.offsetParent because
-         * that can be null if the host element has
-         * position: fixed applied to it.
-         * notchSpacerEl does not have position: fixed.
-         */
-        width === 0 &&
-            notchSpacerEl.offsetParent === null &&
-            win !== undefined &&
-            'IntersectionObserver' in win) {
-            /**
-             * If there is an IO already attached
-             * then that will update the notch
-             * once the element becomes visible.
-             * As a result, there is no need to create
-             * another one.
-             */
-            if (notchVisibilityIO !== undefined) {
-                return;
-            }
-            const io = (notchVisibilityIO = new IntersectionObserver((ev) => {
-                /**
-                 * If the element is visible then we
-                 * can try setting the notch width again.
-                 */
-                if (ev[0].intersectionRatio === 1) {
-                    setNotchWidth();
-                    io.disconnect();
-                    notchVisibilityIO = undefined;
-                }
-            }, 
-            /**
-             * Set the root to be the host element
-             * This causes the IO callback
-             * to be fired in WebKit as soon as the element
-             * is visible. If we used the default root value
-             * then WebKit would only fire the IO callback
-             * after any animations (such as a modal transition)
-             * finished, and there would potentially be a flicker.
-             */
-            { threshold: 0.01, root: el }));
-            io.observe(notchSpacerEl);
-            return;
-        }
-        /**
-         * If the element is visible then we can set the notch width.
-         * The notch is only visible when the label is scaled,
-         * which is why we multiply the width by 0.75 as this is
-         * the same amount the label element is scaled by in the host CSS.
-         * (See $form-control-label-stacked-scale in ionic.globals.scss).
-         */
-        notchSpacerEl.style.setProperty('width', `${width * 0.75}px`);
-    };
-    const destroy = () => {
-        if (notchVisibilityIO) {
-            notchVisibilityIO.disconnect();
-            notchVisibilityIO = undefined;
-        }
-    };
-    return {
-        calculateNotchWidth,
-        destroy,
-    };
-};
-
-export { createNotchController as c };