voyager-ionic-core 7.5.1 → 7.6.0

package/dist/esm/{dir-912e3e13.js → dir-babeabeb.js}

@@ -7,12 +7,12 @@
  * take priority over the root document value.
  */
 const isRTL = (hostEl) => {
-  if (hostEl) {
-    if (hostEl.dir !== '') {
-      return hostEl.dir.toLowerCase() === 'rtl';
+    if (hostEl) {
+        if (hostEl.dir !== '') {
+            return hostEl.dir.toLowerCase() === 'rtl';
+        }
     }
-  }
-  return (document === null || document === void 0 ? void 0 : document.dir.toLowerCase()) === 'rtl';
+    return (document === null || document === void 0 ? void 0 : document.dir.toLowerCase()) === 'rtl';
 };
 
 export { isRTL as i };

package/dist/esm/focus-visible-dd40d69f.js

@@ -0,0 +1,75 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+const ION_FOCUSED = 'ion-focused';
+const ION_FOCUSABLE = 'ion-focusable';
+const FOCUS_KEYS = [
+    'Tab',
+    'ArrowDown',
+    'Space',
+    'Escape',
+    ' ',
+    'Shift',
+    'Enter',
+    'ArrowLeft',
+    'ArrowRight',
+    'ArrowUp',
+    'Home',
+    'End',
+];
+const startFocusVisible = (rootEl) => {
+    let currentFocus = [];
+    let keyboardMode = true;
+    const ref = rootEl ? rootEl.shadowRoot : document;
+    const root = rootEl ? rootEl : document.body;
+    const setFocus = (elements) => {
+        currentFocus.forEach((el) => el.classList.remove(ION_FOCUSED));
+        elements.forEach((el) => el.classList.add(ION_FOCUSED));
+        currentFocus = elements;
+    };
+    const pointerDown = () => {
+        keyboardMode = false;
+        setFocus([]);
+    };
+    const onKeydown = (ev) => {
+        keyboardMode = FOCUS_KEYS.includes(ev.key);
+        if (!keyboardMode) {
+            setFocus([]);
+        }
+    };
+    const onFocusin = (ev) => {
+        if (keyboardMode && ev.composedPath !== undefined) {
+            const toFocus = ev.composedPath().filter((el) => {
+                // TODO(FW-2832): type
+                if (el.classList) {
+                    return el.classList.contains(ION_FOCUSABLE);
+                }
+                return false;
+            });
+            setFocus(toFocus);
+        }
+    };
+    const onFocusout = () => {
+        if (ref.activeElement === root) {
+            setFocus([]);
+        }
+    };
+    ref.addEventListener('keydown', onKeydown);
+    ref.addEventListener('focusin', onFocusin);
+    ref.addEventListener('focusout', onFocusout);
+    ref.addEventListener('touchstart', pointerDown, { passive: true });
+    ref.addEventListener('mousedown', pointerDown);
+    const destroy = () => {
+        ref.removeEventListener('keydown', onKeydown);
+        ref.removeEventListener('focusin', onFocusin);
+        ref.removeEventListener('focusout', onFocusout);
+        ref.removeEventListener('touchstart', pointerDown);
+        ref.removeEventListener('mousedown', pointerDown);
+    };
+    return {
+        destroy,
+        setFocus,
+    };
+};
+
+export { startFocusVisible };

package/dist/esm/form-controller-548aa79c.js

@@ -0,0 +1,64 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { h as findItemLabel } from './helpers-ae653409.js';
+
+/**
+ * Creates a controller that tracks whether a form control is using the legacy or modern syntax. This should be removed when the legacy form control syntax is removed.
+ *
+ * @internal
+ * @prop el: The Ionic form component to reference
+ */
+const createLegacyFormController = (el) => {
+    const controlEl = el;
+    let legacyControl;
+    const hasLegacyControl = () => {
+        if (legacyControl === undefined) {
+            /**
+             * Detect if developers are using the legacy form control syntax
+             * so a deprecation warning is logged. This warning can be disabled
+             * by either using the new `label` property or setting `aria-label`
+             * on the control.
+             * Alternatively, components that use a slot for the label
+             * can check to see if the component has slotted text
+             * in the light DOM.
+             */
+            const hasLabelProp = controlEl.label !== undefined || hasLabelSlot(controlEl);
+            const hasAriaLabelAttribute = controlEl.hasAttribute('aria-label') ||
+                // Shadow DOM form controls cannot use aria-labelledby
+                (controlEl.hasAttribute('aria-labelledby') && controlEl.shadowRoot === null);
+            const legacyItemLabel = findItemLabel(controlEl);
+            /**
+             * Developers can manually opt-out of the modern form markup
+             * by setting `legacy="true"` on components.
+             */
+            legacyControl =
+                controlEl.legacy === true || (!hasLabelProp && !hasAriaLabelAttribute && legacyItemLabel !== null);
+        }
+        return legacyControl;
+    };
+    return { hasLegacyControl };
+};
+const hasLabelSlot = (controlEl) => {
+    /**
+     * Components that have a named label slot
+     * also have other slots, so we need to query for
+     * anything that is explicitly passed to slot="label"
+     */
+    if (NAMED_LABEL_SLOT_COMPONENTS.includes(controlEl.tagName) && controlEl.querySelector('[slot="label"]') !== null) {
+        return true;
+    }
+    /**
+     * Components that have an unnamed slot for the label
+     * have no other slots, so we can check the textContent
+     * of the element.
+     */
+    if (UNNAMED_LABEL_SLOT_COMPONENTS.includes(controlEl.tagName) && controlEl.textContent !== '') {
+        return true;
+    }
+    return false;
+};
+const NAMED_LABEL_SLOT_COMPONENTS = ['ION-INPUT', 'ION-TEXTAREA', 'ION-SELECT', 'ION-RANGE'];
+const UNNAMED_LABEL_SLOT_COMPONENTS = ['ION-TOGGLE', 'ION-CHECKBOX', 'ION-RADIO'];
+
+export { createLegacyFormController as c };

package/dist/esm/framework-delegate-bc1fd82a.js

@@ -0,0 +1,140 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { c as componentOnReady } from './helpers-ae653409.js';
+
+// TODO(FW-2832): types
+const attachComponent = async (delegate, container, component, cssClasses, componentProps, inline) => {
+    var _a;
+    if (delegate) {
+        return delegate.attachViewToDom(container, component, componentProps, cssClasses);
+    }
+    if (!inline && typeof component !== 'string' && !(component instanceof HTMLElement)) {
+        throw new Error('framework delegate is missing');
+    }
+    const el = typeof component === 'string' ? (_a = container.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(component) : component;
+    if (cssClasses) {
+        cssClasses.forEach((c) => el.classList.add(c));
+    }
+    if (componentProps) {
+        Object.assign(el, componentProps);
+    }
+    container.appendChild(el);
+    await new Promise((resolve) => componentOnReady(el, resolve));
+    return el;
+};
+const detachComponent = (delegate, element) => {
+    if (element) {
+        if (delegate) {
+            const container = element.parentElement;
+            return delegate.removeViewFromDom(container, element);
+        }
+        element.remove();
+    }
+    return Promise.resolve();
+};
+const CoreDelegate = () => {
+    let BaseComponent;
+    let Reference;
+    const attachViewToDom = async (parentElement, userComponent, userComponentProps = {}, cssClasses = []) => {
+        var _a, _b;
+        BaseComponent = parentElement;
+        let ChildComponent;
+        /**
+         * If passing in a component via the `component` props
+         * we need to append it inside of our overlay component.
+         */
+        if (userComponent) {
+            /**
+             * If passing in the tag name, create
+             * the element otherwise just get a reference
+             * to the component.
+             */
+            const el = typeof userComponent === 'string' ? (_a = BaseComponent.ownerDocument) === null || _a === void 0 ? void 0 : _a.createElement(userComponent) : userComponent;
+            /**
+             * Add any css classes passed in
+             * via the cssClasses prop on the overlay.
+             */
+            cssClasses.forEach((c) => el.classList.add(c));
+            /**
+             * Add any props passed in
+             * via the componentProps prop on the overlay.
+             */
+            Object.assign(el, userComponentProps);
+            /**
+             * Finally, append the component
+             * inside of the overlay component.
+             */
+            BaseComponent.appendChild(el);
+            ChildComponent = el;
+            await new Promise((resolve) => componentOnReady(el, resolve));
+        }
+        else if (BaseComponent.children.length > 0 &&
+            (BaseComponent.tagName === 'ION-MODAL' || BaseComponent.tagName === 'ION-POPOVER')) {
+            /**
+             * The delegate host wrapper el is only needed for modals and popovers
+             * because they allow the dev to provide custom content to the overlay.
+             */
+            const root = (ChildComponent = BaseComponent.children[0]);
+            if (!root.classList.contains('ion-delegate-host')) {
+                /**
+                 * If the root element is not a delegate host, it means
+                 * that the overlay has not been presented yet and we need
+                 * to create the containing element with the specified classes.
+                 */
+                const el = (_b = BaseComponent.ownerDocument) === null || _b === void 0 ? void 0 : _b.createElement('div');
+                // Add a class to track if the root element was created by the delegate.
+                el.classList.add('ion-delegate-host');
+                cssClasses.forEach((c) => el.classList.add(c));
+                // Move each child from the original template to the new parent element.
+                el.append(...BaseComponent.children);
+                // Append the new parent element to the original parent element.
+                BaseComponent.appendChild(el);
+                /**
+                 * Update the ChildComponent to be the
+                 * newly created div in the event that one
+                 * does not already exist.
+                 */
+                ChildComponent = el;
+            }
+        }
+        /**
+         * Get the root of the app and
+         * add the overlay there.
+         */
+        const app = document.querySelector('ion-app') || document.body;
+        /**
+         * Create a placeholder comment so that
+         * we can return this component to where
+         * it was previously.
+         */
+        Reference = document.createComment('ionic teleport');
+        BaseComponent.parentNode.insertBefore(Reference, BaseComponent);
+        app.appendChild(BaseComponent);
+        /**
+         * We return the child component rather than the overlay
+         * reference itself since modal and popover will
+         * use this to wait for any Ionic components in the child view
+         * to be ready (i.e. componentOnReady) when using the
+         * lazy loaded component bundle.
+         *
+         * However, we fall back to returning BaseComponent
+         * in the event that a modal or popover is presented
+         * with no child content.
+         */
+        return ChildComponent !== null && ChildComponent !== void 0 ? ChildComponent : BaseComponent;
+    };
+    const removeViewFromDom = () => {
+        /**
+         * Return component to where it was previously in the DOM.
+         */
+        if (BaseComponent && Reference) {
+            Reference.parentNode.insertBefore(BaseComponent, Reference);
+            Reference.remove();
+        }
+        return Promise.resolve();
+    };
+    return { attachViewToDom, removeViewFromDom };
+};
+
+export { CoreDelegate as C, attachComponent as a, detachComponent as d };

package/dist/esm/gesture-controller-1bf57181.js

@@ -0,0 +1,195 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+class GestureController {
+    constructor() {
+        this.gestureId = 0;
+        this.requestedStart = new Map();
+        this.disabledGestures = new Map();
+        this.disabledScroll = new Set();
+    }
+    /**
+     * Creates a gesture delegate based on the GestureConfig passed
+     */
+    createGesture(config) {
+        var _a;
+        return new GestureDelegate(this, this.newID(), config.name, (_a = config.priority) !== null && _a !== void 0 ? _a : 0, !!config.disableScroll);
+    }
+    /**
+     * Creates a blocker that will block any other gesture events from firing. Set in the ion-gesture component.
+     */
+    createBlocker(opts = {}) {
+        return new BlockerDelegate(this, this.newID(), opts.disable, !!opts.disableScroll);
+    }
+    start(gestureName, id, priority) {
+        if (!this.canStart(gestureName)) {
+            this.requestedStart.delete(id);
+            return false;
+        }
+        this.requestedStart.set(id, priority);
+        return true;
+    }
+    capture(gestureName, id, priority) {
+        if (!this.start(gestureName, id, priority)) {
+            return false;
+        }
+        const requestedStart = this.requestedStart;
+        let maxPriority = -10000;
+        requestedStart.forEach((value) => {
+            maxPriority = Math.max(maxPriority, value);
+        });
+        if (maxPriority === priority) {
+            this.capturedId = id;
+            requestedStart.clear();
+            const event = new CustomEvent('ionGestureCaptured', { detail: { gestureName } });
+            document.dispatchEvent(event);
+            return true;
+        }
+        requestedStart.delete(id);
+        return false;
+    }
+    release(id) {
+        this.requestedStart.delete(id);
+        if (this.capturedId === id) {
+            this.capturedId = undefined;
+        }
+    }
+    disableGesture(gestureName, id) {
+        let set = this.disabledGestures.get(gestureName);
+        if (set === undefined) {
+            set = new Set();
+            this.disabledGestures.set(gestureName, set);
+        }
+        set.add(id);
+    }
+    enableGesture(gestureName, id) {
+        const set = this.disabledGestures.get(gestureName);
+        if (set !== undefined) {
+            set.delete(id);
+        }
+    }
+    disableScroll(id) {
+        this.disabledScroll.add(id);
+        if (this.disabledScroll.size === 1) {
+            document.body.classList.add(BACKDROP_NO_SCROLL);
+        }
+    }
+    enableScroll(id) {
+        this.disabledScroll.delete(id);
+        if (this.disabledScroll.size === 0) {
+            document.body.classList.remove(BACKDROP_NO_SCROLL);
+        }
+    }
+    canStart(gestureName) {
+        if (this.capturedId !== undefined) {
+            // a gesture already captured
+            return false;
+        }
+        if (this.isDisabled(gestureName)) {
+            return false;
+        }
+        return true;
+    }
+    isCaptured() {
+        return this.capturedId !== undefined;
+    }
+    isScrollDisabled() {
+        return this.disabledScroll.size > 0;
+    }
+    isDisabled(gestureName) {
+        const disabled = this.disabledGestures.get(gestureName);
+        if (disabled && disabled.size > 0) {
+            return true;
+        }
+        return false;
+    }
+    newID() {
+        this.gestureId++;
+        return this.gestureId;
+    }
+}
+class GestureDelegate {
+    constructor(ctrl, id, name, priority, disableScroll) {
+        this.id = id;
+        this.name = name;
+        this.disableScroll = disableScroll;
+        this.priority = priority * 1000000 + id;
+        this.ctrl = ctrl;
+    }
+    canStart() {
+        if (!this.ctrl) {
+            return false;
+        }
+        return this.ctrl.canStart(this.name);
+    }
+    start() {
+        if (!this.ctrl) {
+            return false;
+        }
+        return this.ctrl.start(this.name, this.id, this.priority);
+    }
+    capture() {
+        if (!this.ctrl) {
+            return false;
+        }
+        const captured = this.ctrl.capture(this.name, this.id, this.priority);
+        if (captured && this.disableScroll) {
+            this.ctrl.disableScroll(this.id);
+        }
+        return captured;
+    }
+    release() {
+        if (this.ctrl) {
+            this.ctrl.release(this.id);
+            if (this.disableScroll) {
+                this.ctrl.enableScroll(this.id);
+            }
+        }
+    }
+    destroy() {
+        this.release();
+        this.ctrl = undefined;
+    }
+}
+class BlockerDelegate {
+    constructor(ctrl, id, disable, disableScroll) {
+        this.id = id;
+        this.disable = disable;
+        this.disableScroll = disableScroll;
+        this.ctrl = ctrl;
+    }
+    block() {
+        if (!this.ctrl) {
+            return;
+        }
+        if (this.disable) {
+            for (const gesture of this.disable) {
+                this.ctrl.disableGesture(gesture, this.id);
+            }
+        }
+        if (this.disableScroll) {
+            this.ctrl.disableScroll(this.id);
+        }
+    }
+    unblock() {
+        if (!this.ctrl) {
+            return;
+        }
+        if (this.disable) {
+            for (const gesture of this.disable) {
+                this.ctrl.enableGesture(gesture, this.id);
+            }
+        }
+        if (this.disableScroll) {
+            this.ctrl.enableScroll(this.id);
+        }
+    }
+    destroy() {
+        this.unblock();
+        this.ctrl = undefined;
+    }
+}
+const BACKDROP_NO_SCROLL = 'backdrop-no-scroll';
+const GESTURE_CONTROLLER = new GestureController();
+
+export { GESTURE_CONTROLLER as G };

package/dist/esm/haptic-554688a5.js

@@ -0,0 +1,206 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { g as getCapacitor } from './capacitor-59395cbd.js';
+
+var ImpactStyle;
+(function (ImpactStyle) {
+    /**
+     * A collision between large, heavy user interface elements
+     *
+     * @since 1.0.0
+     */
+    ImpactStyle["Heavy"] = "HEAVY";
+    /**
+     * A collision between moderately sized user interface elements
+     *
+     * @since 1.0.0
+     */
+    ImpactStyle["Medium"] = "MEDIUM";
+    /**
+     * A collision between small, light user interface elements
+     *
+     * @since 1.0.0
+     */
+    ImpactStyle["Light"] = "LIGHT";
+})(ImpactStyle || (ImpactStyle = {}));
+var NotificationType;
+(function (NotificationType) {
+    /**
+     * A notification feedback type indicating that a task has completed successfully
+     *
+     * @since 1.0.0
+     */
+    NotificationType["Success"] = "SUCCESS";
+    /**
+     * A notification feedback type indicating that a task has produced a warning
+     *
+     * @since 1.0.0
+     */
+    NotificationType["Warning"] = "WARNING";
+    /**
+     * A notification feedback type indicating that a task has failed
+     *
+     * @since 1.0.0
+     */
+    NotificationType["Error"] = "ERROR";
+})(NotificationType || (NotificationType = {}));
+const HapticEngine = {
+    getEngine() {
+        const tapticEngine = window.TapticEngine;
+        if (tapticEngine) {
+            // Cordova
+            // TODO FW-4707 - Remove this in Ionic 8
+            return tapticEngine;
+        }
+        const capacitor = getCapacitor();
+        if (capacitor === null || capacitor === void 0 ? void 0 : capacitor.isPluginAvailable('Haptics')) {
+            // Capacitor
+            return capacitor.Plugins.Haptics;
+        }
+        return undefined;
+    },
+    available() {
+        const engine = this.getEngine();
+        if (!engine) {
+            return false;
+        }
+        const capacitor = getCapacitor();
+        /**
+         * Developers can manually import the
+         * Haptics plugin in their app which will cause
+         * getEngine to return the Haptics engine. However,
+         * the Haptics engine will throw an error if
+         * used in a web browser that does not support
+         * the Vibrate API. This check avoids that error
+         * if the browser does not support the Vibrate API.
+         */
+        if ((capacitor === null || capacitor === void 0 ? void 0 : capacitor.getPlatform()) === 'web') {
+            // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+            return typeof navigator !== 'undefined' && navigator.vibrate !== undefined;
+        }
+        return true;
+    },
+    isCordova() {
+        return window.TapticEngine !== undefined;
+    },
+    isCapacitor() {
+        return getCapacitor() !== undefined;
+    },
+    impact(options) {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        /**
+         * To provide backwards compatibility with Cordova apps,
+         * we convert the style to lowercase.
+         *
+         * TODO: FW-4707 - Remove this in Ionic 8
+         */
+        const style = this.isCapacitor() ? options.style : options.style.toLowerCase();
+        engine.impact({ style });
+    },
+    notification(options) {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        /**
+         * To provide backwards compatibility with Cordova apps,
+         * we convert the style to lowercase.
+         *
+         * TODO: FW-4707 - Remove this in Ionic 8
+         */
+        const type = this.isCapacitor() ? options.type : options.type.toLowerCase();
+        engine.notification({ type });
+    },
+    selection() {
+        /**
+         * To provide backwards compatibility with Cordova apps,
+         * we convert the style to lowercase.
+         *
+         * TODO: FW-4707 - Remove this in Ionic 8
+         */
+        const style = this.isCapacitor() ? ImpactStyle.Light : 'light';
+        this.impact({ style });
+    },
+    selectionStart() {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        if (this.isCapacitor()) {
+            engine.selectionStart();
+        }
+        else {
+            engine.gestureSelectionStart();
+        }
+    },
+    selectionChanged() {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        if (this.isCapacitor()) {
+            engine.selectionChanged();
+        }
+        else {
+            engine.gestureSelectionChanged();
+        }
+    },
+    selectionEnd() {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        if (this.isCapacitor()) {
+            engine.selectionEnd();
+        }
+        else {
+            engine.gestureSelectionEnd();
+        }
+    },
+};
+/**
+ * Check to see if the Haptic Plugin is available
+ * @return Returns `true` or false if the plugin is available
+ */
+const hapticAvailable = () => {
+    return HapticEngine.available();
+};
+/**
+ * Trigger a selection changed haptic event. Good for one-time events
+ * (not for gestures)
+ */
+const hapticSelection = () => {
+    hapticAvailable() && HapticEngine.selection();
+};
+/**
+ * Tell the haptic engine that a gesture for a selection change is starting.
+ */
+const hapticSelectionStart = () => {
+    hapticAvailable() && HapticEngine.selectionStart();
+};
+/**
+ * Tell the haptic engine that a selection changed during a gesture.
+ */
+const hapticSelectionChanged = () => {
+    hapticAvailable() && HapticEngine.selectionChanged();
+};
+/**
+ * Tell the haptic engine we are done with a gesture. This needs to be
+ * called lest resources are not properly recycled.
+ */
+const hapticSelectionEnd = () => {
+    hapticAvailable() && HapticEngine.selectionEnd();
+};
+/**
+ * Use this to indicate success/failure/warning to the user.
+ * options should be of the type `{ style: ImpactStyle.LIGHT }` (or `MEDIUM`/`HEAVY`)
+ */
+const hapticImpact = (options) => {
+    hapticAvailable() && HapticEngine.impact(options);
+};
+
+export { ImpactStyle as I, hapticSelectionStart as a, hapticSelectionChanged as b, hapticSelection as c, hapticImpact as d, hapticSelectionEnd as h };