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

package/components/p-cyNmxje6.js

@@ -1,4 +1,158 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-import{g as t}from"./p-CIGNaXM1.js";var n,s;!function(t){t.Heavy="HEAVY",t.Medium="MEDIUM",t.Light="LIGHT"}(n||(n={})),function(t){t.Success="SUCCESS",t.Warning="WARNING",t.Error="ERROR"}(s||(s={}));const i={getEngine(){const n=t();if(null==n?void 0:n.isPluginAvailable("Haptics"))return n.Plugins.Haptics},available(){if(!this.getEngine())return!1;const n=t();return"web"!==(null==n?void 0:n.getPlatform())||"undefined"!=typeof navigator&&void 0!==navigator.vibrate},impact(t){const n=this.getEngine();n&&n.impact({style:t.style})},notification(t){const n=this.getEngine();n&&n.notification({type:t.type})},selection(){this.impact({style:n.Light})},selectionStart(){const t=this.getEngine();t&&t.selectionStart()},selectionChanged(){const t=this.getEngine();t&&t.selectionChanged()},selectionEnd(){const t=this.getEngine();t&&t.selectionEnd()}},o=()=>i.available(),e=()=>{o()&&i.selection()},a=()=>{o()&&i.selectionStart()},c=()=>{o()&&i.selectionChanged()},r=()=>{o()&&i.selectionEnd()},l=t=>{o()&&i.impact(t)};export{n as I,c as a,a as b,l as c,e as d,r as h}
+import { g as getCapacitor } from './p-CIGNaXM1.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 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;
+    },
+    impact(options) {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        engine.impact({ style: options.style });
+    },
+    notification(options) {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        engine.notification({ type: options.type });
+    },
+    selection() {
+        this.impact({ style: ImpactStyle.Light });
+    },
+    selectionStart() {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        engine.selectionStart();
+    },
+    selectionChanged() {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        engine.selectionChanged();
+    },
+    selectionEnd() {
+        const engine = this.getEngine();
+        if (!engine) {
+            return;
+        }
+        engine.selectionEnd();
+    },
+};
+/**
+ * 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, hapticSelectionChanged as a, hapticSelectionStart as b, hapticImpact as c, hapticSelection as d, hapticSelectionEnd as h };

package/components/p-fVuFT3Wd.js

@@ -0,0 +1,78 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { f as clamp } from './p-D5hF6rwn.js';
+import { i as isRTL } from './p-C53feagD.js';
+import { createGesture } from './p-Cl0B-RWe.js';
+
+const createSwipeBackGesture = (el, canStartHandler, onStartHandler, onMoveHandler, onEndHandler) => {
+    const win = el.ownerDocument.defaultView;
+    let rtl = isRTL(el);
+    /**
+     * Determine if a gesture is near the edge
+     * of the screen. If true, then the swipe
+     * to go back gesture should proceed.
+     */
+    const isAtEdge = (detail) => {
+        const threshold = 50;
+        const { startX } = detail;
+        if (rtl) {
+            return startX >= win.innerWidth - threshold;
+        }
+        return startX <= threshold;
+    };
+    const getDeltaX = (detail) => {
+        return rtl ? -detail.deltaX : detail.deltaX;
+    };
+    const getVelocityX = (detail) => {
+        return rtl ? -detail.velocityX : detail.velocityX;
+    };
+    const canStart = (detail) => {
+        /**
+         * The user's locale can change mid-session,
+         * so we need to check text direction at
+         * the beginning of every gesture.
+         */
+        rtl = isRTL(el);
+        return isAtEdge(detail) && canStartHandler();
+    };
+    const onMove = (detail) => {
+        // set the transition animation's progress
+        const delta = getDeltaX(detail);
+        const stepValue = delta / win.innerWidth;
+        onMoveHandler(stepValue);
+    };
+    const onEnd = (detail) => {
+        // the swipe back gesture has ended
+        const delta = getDeltaX(detail);
+        const width = win.innerWidth;
+        const stepValue = delta / width;
+        const velocity = getVelocityX(detail);
+        const z = width / 2.0;
+        const shouldComplete = velocity >= 0 && (velocity > 0.2 || delta > z);
+        const missing = shouldComplete ? 1 - stepValue : stepValue;
+        const missingDistance = missing * width;
+        let realDur = 0;
+        if (missingDistance > 5) {
+            const dur = missingDistance / Math.abs(velocity);
+            realDur = Math.min(dur, 540);
+        }
+        onEndHandler(shouldComplete, stepValue <= 0 ? 0.01 : clamp(0, stepValue, 0.9999), realDur);
+    };
+    return createGesture({
+        el,
+        gestureName: 'goback-swipe',
+        /**
+         * Swipe to go back should have priority over other horizontal swipe
+         * gestures. These gestures have a priority of 100 which is why 101 was chosen here.
+         */
+        gesturePriority: 101,
+        threshold: 10,
+        canStart,
+        onStart: onStartHandler,
+        onMove,
+        onEnd,
+    });
+};
+
+export { createSwipeBackGesture };

package/components/p-hHmYLOfE.js

@@ -1,4 +1,90 @@
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
  */
-const t=(t,M,r,n,e)=>h(t[1],M[1],r[1],n[1],e).map((h=>a(t[0],M[0],r[0],n[0],h))),a=(t,a,h,M,r)=>r*(3*a*Math.pow(r-1,2)+r*(-3*h*r+3*h+M*r))-t*Math.pow(r-1,3),h=(t,a,h,r,n)=>M((r-=n)-3*(h-=n)+3*(a-=n)-(t-=n),3*h-6*a+3*t,3*a-3*t,t).filter((t=>t>=0&&t<=1)),M=(t,a,h,M)=>{if(0===t)return((t,a,h)=>{const M=a*a-4*t*h;return M<0?[]:[(-a+Math.sqrt(M))/(2*t),(-a-Math.sqrt(M))/(2*t)]})(a,h,M);const r=(3*(h/=t)-(a/=t)*a)/3,n=(2*a*a*a-9*a*h+27*(M/=t))/27;if(0===r)return[Math.pow(-n,1/3)];if(0===n)return[Math.sqrt(-r),-Math.sqrt(-r)];const e=Math.pow(n/2,2)+Math.pow(r/3,3);if(0===e)return[Math.pow(n/2,.5)-a/3];if(e>0)return[Math.pow(-n/2+Math.sqrt(e),1/3)-Math.pow(n/2+Math.sqrt(e),1/3)-a/3];const u=Math.sqrt(Math.pow(-r/3,3)),o=Math.acos(-n/(2*Math.sqrt(Math.pow(-r/3,3)))),s=2*Math.pow(u,1/3);return[s*Math.cos(o/3)-a/3,s*Math.cos((o+2*Math.PI)/3)-a/3,s*Math.cos((o+4*Math.PI)/3)-a/3]};export{t as g}
+/**
+ * Based on:
+ * https://stackoverflow.com/questions/7348009/y-coordinate-for-a-given-x-cubic-bezier
+ * https://math.stackexchange.com/questions/26846/is-there-an-explicit-form-for-cubic-b%C3%A9zier-curves
+ */
+/**
+ * EXPERIMENTAL
+ * Given a cubic-bezier curve, get the x value (time) given
+ * the y value (progression).
+ * Ex: cubic-bezier(0.32, 0.72, 0, 1);
+ * P0: (0, 0)
+ * P1: (0.32, 0.72)
+ * P2: (0, 1)
+ * P3: (1, 1)
+ *
+ * If you give a cubic bezier curve that never reaches the
+ * provided progression, this function will return an empty array.
+ */
+const getTimeGivenProgression = (p0, p1, p2, p3, progression) => {
+    return solveCubicBezier(p0[1], p1[1], p2[1], p3[1], progression).map((tValue) => {
+        return solveCubicParametricEquation(p0[0], p1[0], p2[0], p3[0], tValue);
+    });
+};
+/**
+ * Solve a cubic equation in one dimension (time)
+ */
+const solveCubicParametricEquation = (p0, p1, p2, p3, t) => {
+    const partA = 3 * p1 * Math.pow(t - 1, 2);
+    const partB = -3 * p2 * t + 3 * p2 + p3 * t;
+    const partC = p0 * Math.pow(t - 1, 3);
+    return t * (partA + t * partB) - partC;
+};
+/**
+ * Find the `t` value for a cubic bezier using Cardano's formula
+ */
+const solveCubicBezier = (p0, p1, p2, p3, refPoint) => {
+    p0 -= refPoint;
+    p1 -= refPoint;
+    p2 -= refPoint;
+    p3 -= refPoint;
+    const roots = solveCubicEquation(p3 - 3 * p2 + 3 * p1 - p0, 3 * p2 - 6 * p1 + 3 * p0, 3 * p1 - 3 * p0, p0);
+    return roots.filter((root) => root >= 0 && root <= 1);
+};
+const solveQuadraticEquation = (a, b, c) => {
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return [];
+    }
+    else {
+        return [(-b + Math.sqrt(discriminant)) / (2 * a), (-b - Math.sqrt(discriminant)) / (2 * a)];
+    }
+};
+const solveCubicEquation = (a, b, c, d) => {
+    if (a === 0) {
+        return solveQuadraticEquation(b, c, d);
+    }
+    b /= a;
+    c /= a;
+    d /= a;
+    const p = (3 * c - b * b) / 3;
+    const q = (2 * b * b * b - 9 * b * c + 27 * d) / 27;
+    if (p === 0) {
+        return [Math.pow(-q, 1 / 3)];
+    }
+    else if (q === 0) {
+        return [Math.sqrt(-p), -Math.sqrt(-p)];
+    }
+    const discriminant = Math.pow(q / 2, 2) + Math.pow(p / 3, 3);
+    if (discriminant === 0) {
+        return [Math.pow(q / 2, 1 / 2) - b / 3];
+    }
+    else if (discriminant > 0) {
+        return [
+            Math.pow(-(q / 2) + Math.sqrt(discriminant), 1 / 3) - Math.pow(q / 2 + Math.sqrt(discriminant), 1 / 3) - b / 3,
+        ];
+    }
+    const r = Math.sqrt(Math.pow(-(p / 3), 3));
+    const phi = Math.acos(-(q / (2 * Math.sqrt(Math.pow(-(p / 3), 3)))));
+    const s = 2 * Math.pow(r, 1 / 3);
+    return [
+        s * Math.cos(phi / 3) - b / 3,
+        s * Math.cos((phi + 2 * Math.PI) / 3) - b / 3,
+        s * Math.cos((phi + 4 * Math.PI) / 3) - b / 3,
+    ];
+};
+
+export { getTimeGivenProgression as g };