@rdlabo/ionic-theme-ios26 0.4.5 → 1.0.1

package/dist/gestures/animations.d.ts

@@ -0,0 +1,8 @@
+import { Animation, AnimationKeyFrames } from '@ionic/core/dist/types/utils/animation/animation-interface';
+import { AnimationPosition, EffectScales } from './interfaces';
+import { GestureDetail } from '@ionic/core';
+export declare const getScaleAnimation: (effectElement: Element) => Animation;
+export declare const createPreMoveAnimation: (effectElement: Element, tabSelectedElement: Element, currentTouchedElement: Element, animationPosition: AnimationPosition) => Animation;
+export declare const createMoveAnimation: (effectElement: Element, detail: GestureDetail, tabSelectedElement: Element, animationPosition: AnimationPosition) => Animation;
+export declare const getMoveAnimationKeyframe: (type: "moveRight" | "moveLeft" | "slowly", scales: EffectScales) => AnimationKeyFrames;
+//# sourceMappingURL=animations.d.ts.map

package/dist/gestures/animations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations.d.ts","sourceRoot":"","sources":["../../src/gestures/animations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,4DAA4D,CAAC;AAC3G,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAC;AAG7D,eAAO,MAAM,iBAAiB,GAAI,eAAe,OAAO,KAAG,SAE1D,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,eAAe,OAAO,EACtB,oBAAoB,OAAO,EAC3B,uBAAuB,OAAO,EAC9B,mBAAmB,iBAAiB,KACnC,SA0BF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,eAAe,OAAO,EACtB,QAAQ,aAAa,EACrB,oBAAoB,OAAO,EAC3B,mBAAmB,iBAAiB,KACnC,SAiBF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,MAAM,WAAW,GAAG,UAAU,GAAG,QAAQ,EAAE,QAAQ,YAAY,KAAG,kBAqD1G,CAAC"}

package/dist/gestures/animations.js

@@ -0,0 +1,97 @@
+import { createAnimation } from '@ionic/core';
+import { getStep } from './utils';
+export const getScaleAnimation = (effectElement) => {
+    return createAnimation().addElement(effectElement.shadowRoot.querySelector('[part="native"]')).easing('ease-out');
+};
+export const createPreMoveAnimation = (effectElement, tabSelectedElement, currentTouchedElement, animationPosition) => {
+    const diff = Math.max(Math.abs(tabSelectedElement.getBoundingClientRect().left - currentTouchedElement.getBoundingClientRect().left), 120);
+    return createAnimation()
+        .duration(diff * 1.8)
+        .easing('ease-out')
+        .addElement(effectElement)
+        .beforeStyles({
+        width: `${tabSelectedElement.clientWidth}px`,
+        height: `${tabSelectedElement.clientHeight}px`,
+        display: 'block',
+        opacity: '1',
+        transform: 'none',
+    })
+        .keyframes([
+        {
+            offset: 0,
+            transform: `translate3d(${tabSelectedElement.getBoundingClientRect().left}px,  ${animationPosition.positionY}px, 0)`,
+        },
+        {
+            offset: 1,
+            transform: `translate3d(${currentTouchedElement.getBoundingClientRect().left}px,  ${animationPosition.positionY}px, 0)`,
+        },
+    ]);
+};
+export const createMoveAnimation = (effectElement, detail, tabSelectedElement, animationPosition) => {
+    return createAnimation()
+        .duration(500)
+        .addElement(effectElement)
+        .beforeStyles({
+        width: `${tabSelectedElement.clientWidth}px`,
+        height: `${tabSelectedElement.clientHeight}px`,
+        display: 'block',
+        opacity: '1',
+        transform: 'none',
+    })
+        .fromTo('transform', `translate3d(${animationPosition.minPositionX}px, ${animationPosition.positionY}px, 0)`, `translate3d(${animationPosition.maxPositionX}px, ${animationPosition.positionY}px, 0)`)
+        .progressStep(getStep(detail.currentX, animationPosition));
+};
+export const getMoveAnimationKeyframe = (type, scales) => {
+    return {
+        moveRight: [
+            {
+                offset: 0,
+                transform: scales.large,
+            },
+            {
+                offset: 0.4,
+                transform: scales.small,
+            },
+            {
+                offset: 0.75,
+                transform: scales.xlarge,
+            },
+            {
+                offset: 1,
+                transform: scales.large,
+            },
+        ],
+        moveLeft: [
+            {
+                offset: 0,
+                transform: scales.large,
+            },
+            {
+                offset: 0.1,
+                transform: scales.xlarge,
+            },
+            {
+                offset: 0.6,
+                transform: scales.small,
+            },
+            {
+                offset: 1,
+                transform: scales.large,
+            },
+        ],
+        slowly: [
+            {
+                offset: 0,
+                transform: scales.large,
+            },
+            {
+                offset: 0.4,
+                transform: scales.medium,
+            },
+            {
+                offset: 1,
+                transform: scales.large,
+            },
+        ],
+    }[type];
+};

package/dist/gestures/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gestures/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAS9D,eAAO,MAAM,cAAc,GACzB,eAAe,WAAW,EAC1B,eAAe,MAAM,EACrB,mBAAmB,MAAM,EACzB,QAAQ,YAAY,KACnB,gBAAgB,GAAG,SAmRrB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gestures/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAUjF,eAAO,MAAM,cAAc,GACzB,eAAe,WAAW,EAC1B,eAAe,MAAM,EACrB,mBAAmB,MAAM,EACzB,QAAQ,YAAY,KACnB,gBAAgB,GAAG,SAqLrB,CAAC"}

package/dist/gestures/index.js

@@ -1,5 +1,6 @@
-import { createGesture, createAnimation } from '@ionic/core';
-import { cloneElement, getTransform } from './utils';
+import { createGesture } from '@ionic/core';
+import { changeSelectedElement, cloneElement, getStep } from './utils';
+import { createMoveAnimation, createPreMoveAnimation, getMoveAnimationKeyframe, getScaleAnimation } from './animations';
 const GESTURE_NAME = 'ios26-enable-gesture';
 const ANIMATED_NAME = 'ios26-animated';
 export const registerEffect = (targetElement, effectTagName, selectedClassName, scales) => {
@@ -9,22 +10,20 @@ export const registerEffect = (targetElement, effectTagName, selectedClassName,
     let gesture;
     let moveAnimation;
     let currentTouchedElement;
-    let animationLatestX;
-    let effectElementPositionY;
-    let enterAnimationPromise;
-    let moveAnimationPromise;
     let clearActivatedTimer;
+    let animationPosition = undefined;
+    let scaleAnimationPromise;
+    let startAnimationPromise;
+    let maxVelocity = 0;
     const effectElement = cloneElement(effectTagName);
     const onPointerDown = () => {
         clearActivated();
-        currentTouchedElement?.classList.remove('ion-activated');
         gesture.destroy();
         createAnimationGesture();
     };
     const onPointerUp = (event) => {
-        clearActivatedTimer = setTimeout(() => {
-            onEndGesture();
-            currentTouchedElement?.classList.remove('ion-activated');
+        clearActivatedTimer = setTimeout(async () => {
+            await onEndGesture();
             gesture.destroy();
             createAnimationGesture();
         });
@@ -39,7 +38,9 @@ export const registerEffect = (targetElement, effectTagName, selectedClassName,
             gestureName: `${GESTURE_NAME}_${effectTagName}_${crypto.randomUUID()}`,
             onStart: (event) => onStartGesture(event),
             onMove: (event) => onMoveGesture(event),
-            onEnd: () => onEndGesture(),
+            onEnd: () => {
+                onEndGesture().then();
+            },
         });
         gesture.enable(true);
     };
@@ -48,178 +49,94 @@ export const registerEffect = (targetElement, effectTagName, selectedClassName,
         if (!currentTouchedElement) {
             return;
         }
-        requestAnimationFrame(() => {
-            effectElement.style.display = 'none';
-            effectElement.innerHTML = '';
-            effectElement.style.transform = 'none';
-        });
-        targetElement.classList.remove(ANIMATED_NAME);
+        currentTouchedElement.click();
+        currentTouchedElement?.classList.remove('ion-activated');
         currentTouchedElement = undefined;
-        moveAnimation = undefined;
-        moveAnimationPromise = undefined;
-        enterAnimationPromise = undefined;
+        effectElement.style.display = 'none';
+        maxVelocity = 0;
+        targetElement.classList.remove(ANIMATED_NAME);
     };
     const onStartGesture = (detail) => {
-        enterAnimationPromise = undefined;
         currentTouchedElement = detail.event.target.closest(effectTagName) || undefined;
         const tabSelectedElement = targetElement.querySelector(`${effectTagName}.${selectedClassName}`);
         if (currentTouchedElement === undefined || tabSelectedElement === null) {
             return false;
         }
-        effectElementPositionY = tabSelectedElement.getBoundingClientRect().top;
-        const startTransform = getTransform(tabSelectedElement.getBoundingClientRect().left + tabSelectedElement.clientWidth / 2, effectElementPositionY, tabSelectedElement);
-        const middleTransform = getTransform((tabSelectedElement.getBoundingClientRect().left + tabSelectedElement.clientWidth / 2 + detail.currentX) / 2, effectElementPositionY, currentTouchedElement);
-        const endTransform = getTransform(detail.currentX, effectElementPositionY, currentTouchedElement);
-        const enterAnimation = createAnimation();
-        enterAnimation
-            .addElement(effectElement)
-            .delay(70)
-            .beforeStyles({
-            width: `${tabSelectedElement.clientWidth}px`,
-            height: `${tabSelectedElement.clientHeight}px`,
-            display: 'block',
-        })
-            .beforeAddWrite(() => {
-            tabSelectedElement.childNodes.forEach((node) => {
-                effectElement.appendChild(node.cloneNode(true));
-            });
-            targetElement.classList.add(ANIMATED_NAME);
-            currentTouchedElement.classList.add('ion-activated');
-            currentTouchedElement.click();
-        });
-        if (currentTouchedElement === tabSelectedElement) {
-            enterAnimation
-                .keyframes([
-                {
-                    transform: `${startTransform} ${scales.small}`,
-                    opacity: 1,
-                    offset: 0,
-                },
-                {
-                    transform: `${middleTransform} ${scales.large}`,
-                    opacity: 1,
-                    offset: 0.6,
-                },
-                {
-                    transform: `${endTransform} ${scales.medium}`,
-                    opacity: 1,
-                    offset: 1,
-                },
-            ])
-                .duration(160);
-        }
-        else {
-            enterAnimation
-                .keyframes([
-                {
-                    transform: `${startTransform} ${scales.small}`,
-                    opacity: 1,
-                    offset: 0,
-                },
-                {
-                    transform: `${middleTransform} ${scales.large}`,
-                    opacity: 1,
-                    offset: 0.65,
-                },
-                {
-                    transform: `${endTransform} ${scales.medium}`,
-                    opacity: 1,
-                    offset: 1,
-                },
-            ])
-                .duration(280);
-        }
-        animationLatestX = detail.currentX;
-        enterAnimationPromise = enterAnimation.play().then(() => {
-            enterAnimationPromise = undefined;
+        animationPosition = {
+            minPositionX: targetElement.getBoundingClientRect().left,
+            maxPositionX: targetElement.getBoundingClientRect().right - tabSelectedElement.clientWidth,
+            width: tabSelectedElement.clientWidth,
+            positionY: tabSelectedElement.getBoundingClientRect().top,
+        };
+        targetElement.classList.add(ANIMATED_NAME);
+        changeSelectedElement(targetElement, currentTouchedElement, effectTagName, selectedClassName);
+        startAnimationPromise = (() => {
+            if (tabSelectedElement === currentTouchedElement) {
+                return new Promise((resolve) => resolve());
+            }
+            else {
+                const preMoveAnimation = createPreMoveAnimation(effectElement, tabSelectedElement, currentTouchedElement, animationPosition);
+                return preMoveAnimation.play().finally(() => preMoveAnimation.destroy());
+            }
+        })();
+        startAnimationPromise.then(() => {
+            moveAnimation = createMoveAnimation(effectElement, detail, tabSelectedElement, animationPosition);
+            moveAnimation.progressStart(true, getStep(currentTouchedElement.getBoundingClientRect().left + currentTouchedElement.clientWidth / 2, animationPosition));
         });
+        getScaleAnimation(effectElement).duration(200).to('opacity', 1).to('transform', scales.large).play();
         return true;
     };
     const onMoveGesture = (detail) => {
-        if (currentTouchedElement === undefined || enterAnimationPromise || moveAnimationPromise) {
-            return true;
+        if (currentTouchedElement === undefined || !moveAnimation) {
+            return false;
         }
-        const startTransform = getTransform(animationLatestX, effectElementPositionY, currentTouchedElement);
-        const endTransform = getTransform(detail.currentX, effectElementPositionY, currentTouchedElement);
-        if (!moveAnimation) {
-            moveAnimation = createAnimation();
-            moveAnimation
-                .addElement(effectElement)
-                .duration(800)
-                .easing('ease-in-out')
-                .keyframes([
-                {
-                    transform: `${startTransform} ${scales.medium}`,
-                    opacity: 1,
-                    offset: 0,
-                },
-                {
-                    transform: `${startTransform} ${scales.xlarge}`,
-                    opacity: 1,
-                    offset: 0.2,
-                },
-                {
-                    transform: `${endTransform} ${scales.medium}`,
-                    opacity: 1,
-                    offset: 1,
-                },
-            ]);
+        if (scaleAnimationPromise === undefined) {
+            if (Math.abs(detail.velocityX) > maxVelocity) {
+                maxVelocity = Math.abs(detail.velocityX);
+            }
+            if (Math.abs(detail.velocityX) > 0.2) {
+                scaleAnimationPromise = getScaleAnimation(effectElement)
+                    .duration(720)
+                    .keyframes(getMoveAnimationKeyframe('slowly', scales))
+                    .play()
+                    .finally(() => (scaleAnimationPromise = undefined));
+            }
+            if (maxVelocity > 0.2 && Math.abs(detail.velocityX) < 0.15 && Math.abs(detail.startX - detail.currentX) > 100) {
+                scaleAnimationPromise = getScaleAnimation(effectElement)
+                    .duration(720)
+                    .keyframes(getMoveAnimationKeyframe(detail.velocityX > 0 ? 'moveRight' : 'moveLeft', scales))
+                    .play()
+                    .finally(() => (scaleAnimationPromise = undefined));
+                maxVelocity = 0;
+            }
         }
-        else {
-            moveAnimation.duration(0).keyframes([
-                {
-                    transform: `${endTransform} ${scales.medium}`,
-                    opacity: 1,
-                    offset: 1,
-                },
-                {
-                    transform: `${endTransform} ${scales.medium}`,
-                    opacity: 1,
-                    offset: 1,
-                },
-            ]);
+        const latestTouchedElement = detail.event.target.closest(effectTagName) || undefined;
+        if (latestTouchedElement && currentTouchedElement !== latestTouchedElement) {
+            currentTouchedElement = latestTouchedElement;
+            changeSelectedElement(targetElement, currentTouchedElement, effectTagName, selectedClassName);
         }
-        animationLatestX = detail.currentX;
-        moveAnimationPromise = moveAnimation.play().then(() => {
-            moveAnimationPromise = undefined;
-        });
+        moveAnimation.progressStep(getStep(detail.currentX, animationPosition));
         return true;
     };
-    const onEndGesture = () => {
+    const onEndGesture = async () => {
         if (clearActivatedTimer !== undefined) {
             clearTimeout(clearActivatedTimer);
             clearActivatedTimer = undefined;
         }
-        if (currentTouchedElement === undefined) {
+        if (startAnimationPromise) {
+            await startAnimationPromise;
+        }
+        if (currentTouchedElement === undefined || !moveAnimation) {
             return false;
         }
-        const transform = getTransform(animationLatestX, effectElementPositionY, currentTouchedElement);
-        const leaveAnimation = createAnimation();
-        leaveAnimation.addElement(effectElement);
-        leaveAnimation
-            .onFinish(() => clearActivated())
-            .easing('ease-in')
-            .duration(80)
-            .keyframes([
-            {
-                transform: `${transform} ${scales.medium}`,
-                opacity: 1,
-            },
-            {
-                transform: `${transform} ${scales.small}`,
-                opacity: 0,
-            },
-        ]);
-        (async () => {
-            if (enterAnimationPromise) {
-                setTimeout(() => currentTouchedElement.classList.remove('ion-activated'), 50);
-                await enterAnimationPromise;
-            }
-            else {
-                currentTouchedElement.classList.remove('ion-activated');
-            }
-            leaveAnimation.play();
-        })();
+        setTimeout(() => {
+            const targetX = currentTouchedElement.getBoundingClientRect().left + currentTouchedElement.clientWidth / 2;
+            const step = getStep(targetX, animationPosition);
+            moveAnimation.progressStep(step);
+        });
+        await getScaleAnimation(effectElement).duration(120).to('transform', `scale(1, 0.92)`).play();
+        moveAnimation.destroy();
+        clearActivated();
         return true;
     };
     return {

package/dist/gestures/interfaces.d.ts

@@ -7,4 +7,10 @@ export interface EffectScales {
 export interface registeredEffect {
     destroy: () => void;
 }
+export interface AnimationPosition {
+    minPositionX: number;
+    maxPositionX: number;
+    width: number;
+    positionY: number;
+}
 //# sourceMappingURL=interfaces.d.ts.map

package/dist/gestures/interfaces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/gestures/interfaces.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB"}
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/gestures/interfaces.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/gestures/utils.d.ts

@@ -1,3 +1,5 @@
+import { AnimationPosition } from './interfaces';
 export declare const cloneElement: (tagName: string) => HTMLElement;
-export declare const getTransform: (detailCurrentX: number, tabEffectElY: number, tabSelectedActual: Element) => string;
+export declare const getStep: (targetX: number, animationPosition: AnimationPosition) => number;
+export declare const changeSelectedElement: (targetElement: HTMLElement, selectedElement: HTMLElement, effectTagName: string, selectedClassName: string) => void;
 //# sourceMappingURL=utils.d.ts.map

package/dist/gestures/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/gestures/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,WAY9C,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,gBAAgB,MAAM,EAAE,cAAc,MAAM,EAAE,mBAAmB,OAAO,KAAG,MAavG,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/gestures/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,WAY9C,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,SAAS,MAAM,EAAE,mBAAmB,iBAAiB,WAQ5E,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,eAAe,WAAW,EAC1B,iBAAiB,WAAW,EAC5B,eAAe,MAAM,EACrB,mBAAmB,MAAM,KACxB,IAMF,CAAC"}

package/dist/gestures/utils.js

@@ -9,16 +9,19 @@ export const cloneElement = (tagName) => {
     document.body.appendChild(clonedEl);
     return clonedEl;
 };
-export const getTransform = (detailCurrentX, tabEffectElY, tabSelectedActual) => {
-    const diff = -2;
-    const currentX = detailCurrentX - tabSelectedActual.clientWidth / 2;
-    const maxLeft = tabSelectedActual.getBoundingClientRect().left + diff;
-    const maxRight = tabSelectedActual.getBoundingClientRect().right - diff - tabSelectedActual.clientWidth;
-    if (maxLeft < currentX && currentX < maxRight) {
-        return `translate3d(${currentX}px, ${tabEffectElY}px, 0)`;
+export const getStep = (targetX, animationPosition) => {
+    if (animationPosition === undefined) {
+        return 0;
     }
-    if (maxLeft > currentX) {
-        return `translate3d(${maxLeft}px, ${tabEffectElY}px, 0)`;
-    }
-    return `translate3d(${maxRight}px, ${tabEffectElY}px, 0)`;
+    const currentX = targetX - animationPosition.width / 2;
+    let progress = (currentX - animationPosition.minPositionX) / (animationPosition.maxPositionX - animationPosition.minPositionX);
+    progress = Math.max(0, Math.min(1, progress));
+    return progress;
+};
+export const changeSelectedElement = (targetElement, selectedElement, effectTagName, selectedClassName) => {
+    targetElement.querySelectorAll(effectTagName).forEach((element) => {
+        element.classList.remove(selectedClassName);
+        element.classList.remove('ion-activated');
+    });
+    selectedElement.classList.add(selectedClassName, 'ion-activated');
 };

package/dist/index.js

@@ -2,10 +2,10 @@ import { registerEffect } from './gestures';
 export * from './gestures/interfaces';
 export const registerTabBarEffect = (targetElement) => {
     return registerEffect(targetElement, 'ion-tab-button', 'tab-selected', {
-        small: 'scale(1.1)',
+        small: 'scale(1.1, 1)',
         medium: 'scale(1.2)',
         large: 'scale(1.3)',
-        xlarge: 'scale(1.3, 1.5)',
+        xlarge: 'scale(1.15, 1.4)',
     });
 };
 export const registerSegmentEffect = (targetElement) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rdlabo/ionic-theme-ios26",
-  "version": "0.4.5",
-  "description": "iOS26 CSS Theme for Ionic Framework",
+  "version": "1.0.1",
+  "description": "iOS26 Theme for Ionic Framework",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/gestures/animations.ts

@@ -0,0 +1,120 @@
+import { Animation, AnimationKeyFrames } from '@ionic/core/dist/types/utils/animation/animation-interface';
+import { AnimationPosition, EffectScales } from './interfaces';
+import { createAnimation, GestureDetail } from '@ionic/core';
+import { getStep } from './utils';
+
+export const getScaleAnimation = (effectElement: Element): Animation => {
+  return createAnimation().addElement(effectElement.shadowRoot!.querySelector<HTMLElement>('[part="native"]')!).easing('ease-out');
+};
+
+export const createPreMoveAnimation = (
+  effectElement: Element,
+  tabSelectedElement: Element,
+  currentTouchedElement: Element,
+  animationPosition: AnimationPosition,
+): Animation => {
+  const diff = Math.max(
+    Math.abs(tabSelectedElement.getBoundingClientRect().left - currentTouchedElement.getBoundingClientRect().left),
+    120,
+  );
+  return createAnimation()
+    .duration(diff * 1.8)
+    .easing('ease-out')
+    .addElement(effectElement)
+    .beforeStyles({
+      width: `${tabSelectedElement.clientWidth}px`,
+      height: `${tabSelectedElement.clientHeight}px`,
+      display: 'block',
+      opacity: '1',
+      transform: 'none',
+    })
+    .keyframes([
+      {
+        offset: 0,
+        transform: `translate3d(${tabSelectedElement.getBoundingClientRect().left}px,  ${animationPosition.positionY}px, 0)`,
+      },
+      {
+        offset: 1,
+        transform: `translate3d(${currentTouchedElement.getBoundingClientRect().left}px,  ${animationPosition.positionY}px, 0)`,
+      },
+    ]);
+};
+
+export const createMoveAnimation = (
+  effectElement: Element,
+  detail: GestureDetail,
+  tabSelectedElement: Element,
+  animationPosition: AnimationPosition,
+): Animation => {
+  return createAnimation()
+    .duration(500)
+    .addElement(effectElement)
+    .beforeStyles({
+      width: `${tabSelectedElement.clientWidth}px`,
+      height: `${tabSelectedElement.clientHeight}px`,
+      display: 'block',
+      opacity: '1',
+      transform: 'none',
+    })
+    .fromTo(
+      'transform',
+      `translate3d(${animationPosition.minPositionX}px, ${animationPosition.positionY}px, 0)`,
+      `translate3d(${animationPosition.maxPositionX}px, ${animationPosition.positionY}px, 0)`,
+    )
+    .progressStep(getStep(detail.currentX, animationPosition));
+};
+
+export const getMoveAnimationKeyframe = (type: 'moveRight' | 'moveLeft' | 'slowly', scales: EffectScales): AnimationKeyFrames => {
+  return {
+    moveRight: [
+      {
+        offset: 0,
+        transform: scales.large,
+      },
+      {
+        offset: 0.4,
+        transform: scales.small,
+      },
+      {
+        offset: 0.75,
+        transform: scales.xlarge,
+      },
+      {
+        offset: 1,
+        transform: scales.large,
+      },
+    ],
+    moveLeft: [
+      {
+        offset: 0,
+        transform: scales.large,
+      },
+      {
+        offset: 0.1,
+        transform: scales.xlarge,
+      },
+      {
+        offset: 0.6,
+        transform: scales.small,
+      },
+      {
+        offset: 1,
+        transform: scales.large,
+      },
+    ],
+    slowly: [
+      {
+        offset: 0,
+        transform: scales.large,
+      },
+      {
+        offset: 0.4,
+        transform: scales.medium,
+      },
+      {
+        offset: 1,
+        transform: scales.large,
+      },
+    ],
+  }[type];
+};