Initial commit

src/components/cardStack/hooks/useCardAnimation.ts

@@ -0,0 +1,126 @@
+import { useRef } from "react";
+import { useGSAP } from "@gsap/react";
+import gsap from "gsap";
+import { ScrollTrigger } from "gsap/ScrollTrigger";
+import type { CardAnimationType, GridVariant } from "../types";
+import { useDepth3DAnimation } from "./useDepth3DAnimation";
+
+gsap.registerPlugin(ScrollTrigger);
+
+interface UseCardAnimationProps {
+  animationType: CardAnimationType | "depth-3d";
+  itemCount: number;
+  isGrid?: boolean;
+  supports3DAnimation?: boolean;
+  gridVariant?: GridVariant;
+}
+
+export const useCardAnimation = ({
+  animationType,
+  itemCount,
+  isGrid = true,
+  supports3DAnimation = false,
+  gridVariant
+}: UseCardAnimationProps) => {
+  const itemRefs = useRef<(HTMLElement | null)[]>([]);
+  const containerRef = useRef<HTMLDivElement | null>(null);
+  const perspectiveRef = useRef<HTMLDivElement | null>(null);
+  const bottomContentRef = useRef<HTMLDivElement | null>(null);
+
+  // Enable 3D effect only when explicitly supported and conditions are met
+  const { isMobile } = useDepth3DAnimation({
+    itemRefs,
+    containerRef,
+    perspectiveRef,
+    isEnabled: animationType === "depth-3d" && isGrid && supports3DAnimation && gridVariant === "uniform-all-items-equal",
+  });
+
+  // Use scale-rotate as fallback when depth-3d conditions aren't met
+  const effectiveAnimationType =
+    animationType === "depth-3d" && (isMobile || !isGrid || gridVariant !== "uniform-all-items-equal")
+      ? "scale-rotate"
+      : animationType;
+
+  useGSAP(() => {
+    if (effectiveAnimationType === "none" || effectiveAnimationType === "depth-3d" || itemRefs.current.length === 0) return;
+
+    const items = itemRefs.current.filter((el) => el !== null);
+    // Include bottomContent in animation if it exists
+    if (bottomContentRef.current) {
+      items.push(bottomContentRef.current);
+    }
+
+    if (effectiveAnimationType === "opacity") {
+      gsap.fromTo(
+        items,
+        { opacity: 0 },
+        {
+          opacity: 1,
+          duration: 1.25,
+          stagger: 0.15,
+          ease: "sine",
+          scrollTrigger: {
+            trigger: items[0],
+            start: "top 80%",
+            toggleActions: "play none none none",
+          },
+        }
+      );
+    } else if (effectiveAnimationType === "slide-up") {
+      items.forEach((item, index) => {
+        gsap.fromTo(
+          item,
+          { opacity: 0, yPercent: 15 },
+          {
+            opacity: 1,
+            yPercent: 0,
+            duration: 1,
+            delay: index * 0.15,
+            ease: "sine",
+            scrollTrigger: {
+              trigger: items[0],
+              start: "top 80%",
+              toggleActions: "play none none none",
+            },
+          }
+        );
+      });
+    } else if (effectiveAnimationType === "scale-rotate") {
+      gsap.fromTo(
+        items,
+        { scaleX: 0, rotate: 10 },
+        {
+          scaleX: 1,
+          rotate: 0,
+          duration: 1,
+          stagger: 0.15,
+          ease: "power3",
+          scrollTrigger: {
+            trigger: items[0],
+            start: "top 80%",
+            toggleActions: "play none none none",
+          },
+        }
+      );
+    } else if (effectiveAnimationType === "blur-reveal") {
+      gsap.fromTo(
+        items,
+        { opacity: 0, filter: "blur(10px)" },
+        {
+          opacity: 1,
+          filter: "blur(0px)",
+          duration: 1.2,
+          stagger: 0.15,
+          ease: "power2.out",
+          scrollTrigger: {
+            trigger: items[0],
+            start: "top 80%",
+            toggleActions: "play none none none",
+          },
+        }
+      );
+    }
+  }, [effectiveAnimationType, itemCount]);
+
+  return { itemRefs, containerRef, perspectiveRef, bottomContentRef };
+};

src/components/cardStack/hooks/useDepth3DAnimation.ts

@@ -0,0 +1,118 @@
+import { useEffect, useState, useRef, RefObject } from "react";
+
+const MOBILE_BREAKPOINT = 768;
+const ANIMATION_SPEED = 0.05;
+const ROTATION_SPEED = 0.1;
+const MOUSE_MULTIPLIER = 0.5;
+const ROTATION_MULTIPLIER = 0.25;
+
+interface UseDepth3DAnimationProps {
+  itemRefs: RefObject<(HTMLElement | null)[]>;
+  containerRef: RefObject<HTMLDivElement | null>;
+  perspectiveRef?: RefObject<HTMLDivElement | null>;
+  isEnabled: boolean;
+}
+
+export const useDepth3DAnimation = ({
+  itemRefs,
+  containerRef,
+  perspectiveRef,
+  isEnabled,
+}: UseDepth3DAnimationProps) => {
+  const [isMobile, setIsMobile] = useState(false);
+
+  // Detect mobile viewport
+  useEffect(() => {
+    const checkMobile = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    };
+
+    checkMobile();
+    window.addEventListener("resize", checkMobile);
+
+    return () => {
+      window.removeEventListener("resize", checkMobile);
+    };
+  }, []);
+
+  // 3D mouse-tracking effect (desktop only)
+  useEffect(() => {
+    if (!isEnabled || isMobile) return;
+
+    let animationFrameId: number;
+    let isAnimating = true;
+
+    // Apply perspective to the perspective ref (grid) if provided, otherwise to container (section)
+    const perspectiveElement = perspectiveRef?.current || containerRef.current;
+    if (perspectiveElement) {
+      perspectiveElement.style.perspective = "1200px";
+      perspectiveElement.style.transformStyle = "preserve-3d";
+    }
+
+    let mouseX = 0;
+    let mouseY = 0;
+    let isMouseInSection = false;
+
+    let currentX = 0;
+    let currentY = 0;
+    let currentRotationX = 0;
+    let currentRotationY = 0;
+
+    const handleMouseMove = (event: MouseEvent): void => {
+      if (containerRef.current) {
+        const rect = containerRef.current.getBoundingClientRect();
+        isMouseInSection =
+          event.clientX >= rect.left &&
+          event.clientX <= rect.right &&
+          event.clientY >= rect.top &&
+          event.clientY <= rect.bottom;
+      }
+
+      if (isMouseInSection) {
+        mouseX = (event.clientX / window.innerWidth) * 100 - 50;
+        mouseY = (event.clientY / window.innerHeight) * 100 - 50;
+      }
+    };
+
+    const animate = (): void => {
+      if (!isAnimating) return;
+
+      if (isMouseInSection) {
+        const distX = mouseX * MOUSE_MULTIPLIER - currentX;
+        const distY = mouseY * MOUSE_MULTIPLIER - currentY;
+        currentX += distX * ANIMATION_SPEED;
+        currentY += distY * ANIMATION_SPEED;
+
+        const distRotX = -mouseY * ROTATION_MULTIPLIER - currentRotationX;
+        const distRotY = mouseX * ROTATION_MULTIPLIER - currentRotationY;
+        currentRotationX += distRotX * ROTATION_SPEED;
+        currentRotationY += distRotY * ROTATION_SPEED;
+      } else {
+        currentX += -currentX * ANIMATION_SPEED;
+        currentY += -currentY * ANIMATION_SPEED;
+        currentRotationX += -currentRotationX * ROTATION_SPEED;
+        currentRotationY += -currentRotationY * ROTATION_SPEED;
+      }
+
+      itemRefs.current?.forEach((ref) => {
+        if (!ref) return;
+        ref.style.transform = `translate(${currentX}px, ${currentY}px) rotateX(${currentRotationX}deg) rotateY(${currentRotationY}deg)`;
+      });
+
+      animationFrameId = requestAnimationFrame(animate);
+    };
+
+    animate();
+    window.addEventListener("mousemove", handleMouseMove);
+
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+      if (animationFrameId) {
+        cancelAnimationFrame(animationFrameId);
+      }
+      isAnimating = false;
+    };
+  }, [isEnabled, isMobile, itemRefs, containerRef]);
+
+  return { isMobile };
+};

src/components/cardStack/hooks/usePhoneAnimations.ts

@@ -0,0 +1,108 @@
+import { useEffect, useRef } from "react";
+import { gsap } from "gsap";
+import { ScrollTrigger } from "gsap/ScrollTrigger";
+
+gsap.registerPlugin(ScrollTrigger);
+
+export interface TimelinePhoneViewItem {
+  trigger: string;
+  content: React.ReactNode;
+  imageOne?: string;
+  videoOne?: string;
+  imageAltOne?: string;
+  videoAriaLabelOne?: string;
+  imageTwo?: string;
+  videoTwo?: string;
+  imageAltTwo?: string;
+  videoAriaLabelTwo?: string;
+}
+
+const getImageAnimationConfig = (itemIndex: number, imageIndex: number) => {
+  const isFirstImage = imageIndex === 0;
+  const isOddItem = itemIndex % 2 === 1;
+
+  if (isFirstImage) {
+    return {
+      from: { xPercent: -200, rotation: -45 },
+      to: { rotation: isOddItem ? 10 : -10 },
+    };
+  } else {
+    return {
+      from: { xPercent: 200, rotation: 45 },
+      to: { rotation: isOddItem ? -10 : 10 },
+    };
+  }
+};
+
+export const usePhoneAnimations = (items: TimelinePhoneViewItem[]) => {
+  const imageRefs = useRef<(HTMLDivElement | null)[]>([]);
+  const mobileImageRefs = useRef<(HTMLDivElement | null)[]>([]);
+
+  useEffect(() => {
+    const mm = gsap.matchMedia();
+
+    const animatePhones = (isMobile: boolean) => {
+      items.forEach((item, itemIndex) => {
+        const images = [item.imageOne || item.videoOne, item.imageTwo || item.videoTwo];
+
+        images.forEach((_, imageIndex) => {
+          const refIndex = itemIndex * 2 + imageIndex;
+          const element = isMobile
+            ? mobileImageRefs.current[refIndex]
+            : imageRefs.current[refIndex];
+
+          if (element) {
+            const isFirstImage = imageIndex === 0;
+
+            const fromConfig = isMobile
+              ? {
+                  xPercent: isFirstImage ? -150 : 150,
+                  rotation: isFirstImage ? -25 : 25,
+                }
+              : getImageAnimationConfig(itemIndex, imageIndex).from;
+
+            const toConfig = isMobile
+              ? {
+                  xPercent: 0,
+                  rotation: 0,
+                  duration: 1,
+                  scrollTrigger: {
+                    trigger: element,
+                    start: "top 90%",
+                    end: "top 50%",
+                    scrub: 1,
+                  },
+                }
+              : {
+                  xPercent: 0,
+                  rotation: getImageAnimationConfig(itemIndex, imageIndex).to
+                    .rotation,
+                  scrollTrigger: {
+                    trigger: `.${item.trigger}`,
+                    start: "top bottom",
+                    end: "top top",
+                    scrub: 1,
+                  },
+                };
+
+            gsap.fromTo(element, fromConfig, toConfig);
+          }
+        });
+      });
+    };
+
+    mm.add("(max-width: 767px)", () => animatePhones(true));
+    mm.add("(min-width: 768px)", () => animatePhones(false));
+
+    return () => {
+      mm.revert();
+      imageRefs.current = [];
+      mobileImageRefs.current = [];
+    };
+  }, [items]);
+
+  return {
+    imageRefs,
+    mobileImageRefs,
+  };
+};

src/components/cardStack/hooks/usePrevNextButtons.ts

@@ -0,0 +1,40 @@
+import { useCallback, useEffect, useState } from "react";
+import { EmblaCarouselType } from "embla-carousel";
+
+export const usePrevNextButtons = (emblaApi: EmblaCarouselType | undefined) => {
+    const [prevBtnDisabled, setPrevBtnDisabled] = useState(true);
+    const [nextBtnDisabled, setNextBtnDisabled] = useState(true);
+
+    const onPrevButtonClick = useCallback(() => {
+        if (!emblaApi) return;
+        emblaApi.scrollPrev();
+    }, [emblaApi]);
+
+    const onNextButtonClick = useCallback(() => {
+        if (!emblaApi) return;
+        emblaApi.scrollNext();
+    }, [emblaApi]);
+
+    const onSelect = useCallback((emblaApi: EmblaCarouselType) => {
+        setPrevBtnDisabled(!emblaApi.canScrollPrev());
+        setNextBtnDisabled(!emblaApi.canScrollNext());
+    }, []);
+
+    useEffect(() => {
+        if (!emblaApi) return;
+
+        onSelect(emblaApi);
+        emblaApi.on("reInit", onSelect).on("select", onSelect);
+
+        return () => {
+            emblaApi.off("reInit", onSelect).off("select", onSelect);
+        };
+    }, [emblaApi, onSelect]);
+
+    return {
+        prevBtnDisabled,
+        nextBtnDisabled,
+        onPrevButtonClick,
+        onNextButtonClick,
+    };
+};

src/components/cardStack/hooks/useScrollProgress.ts

@@ -0,0 +1,30 @@
+import { useCallback, useEffect, useState } from "react";
+import { EmblaCarouselType } from "embla-carousel";
+
+export const useScrollProgress = (emblaApi: EmblaCarouselType | undefined) => {
+    const [scrollProgress, setScrollProgress] = useState(0);
+
+    const onScroll = useCallback((emblaApi: EmblaCarouselType) => {
+        const progress = Math.max(0, Math.min(1, emblaApi.scrollProgress()));
+        setScrollProgress(progress * 100);
+    }, []);
+
+    useEffect(() => {
+        if (!emblaApi) return;
+
+        onScroll(emblaApi);
+        emblaApi
+            .on("reInit", onScroll)
+            .on("scroll", onScroll)
+            .on("slideFocus", onScroll);
+
+        return () => {
+            emblaApi
+                .off("reInit", onScroll)
+                .off("scroll", onScroll)
+                .off("slideFocus", onScroll);
+        };
+    }, [emblaApi, onScroll]);
+
+    return scrollProgress;
+};

src/components/cardStack/hooks/useTimelineHorizontal.ts

@@ -0,0 +1,243 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+
+const ANIMATION_CONFIG = {
+  PROGRESS_DURATION: 5000,
+  TRANSITION_DURATION: 500,
+  ANIMATION_START_DELAY: 100,
+  IMAGE_TRANSITION_DELAY: 300,
+} as const;
+
+export interface MediaItem {
+  imageSrc?: string;
+  videoSrc?: string;
+  imageAlt?: string;
+  videoAriaLabel?: string;
+}
+
+interface UseTimelineHorizontalProps {
+  itemCount: number;
+  mediaItems?: MediaItem[];
+}
+
+export const useTimelineHorizontal = ({ itemCount, mediaItems }: UseTimelineHorizontalProps) => {
+  const [activeIndex, setActiveIndex] = useState(0);
+  const [imageOpacity, setImageOpacity] = useState(1);
+  const [currentMediaSrc, setCurrentMediaSrc] = useState<{ imageSrc?: string; videoSrc?: string }>(() => {
+    if (mediaItems && mediaItems[0]) {
+      return {
+        imageSrc: mediaItems[0].imageSrc,
+        videoSrc: mediaItems[0].videoSrc,
+      };
+    }
+    return {};
+  });
+  const progressRefs = useRef<(HTMLDivElement | null)[]>([]);
+  const animationFrameRef = useRef<number | null>(null);
+  const imageTransitionTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+  const isMountedRef = useRef(false);
+  const hasInitializedRef = useRef(false);
+
+  const resetAllProgressBars = useCallback(() => {
+    if (animationFrameRef.current) {
+      cancelAnimationFrame(animationFrameRef.current);
+    }
+
+    progressRefs.current.forEach((bar) => {
+      if (bar) {
+        bar.style.transition = `transform ${ANIMATION_CONFIG.TRANSITION_DURATION}ms ease-in-out`;
+        bar.style.transform = "scaleX(0)";
+
+        setTimeout(() => {
+          if (bar) {
+            bar.style.transition = "none";
+          }
+        }, ANIMATION_CONFIG.TRANSITION_DURATION);
+      }
+    });
+  }, []);
+
+  const animateProgress = useCallback(
+    (index: number) => {
+      if (!progressRefs.current[index]) return;
+
+      if (animationFrameRef.current) {
+        cancelAnimationFrame(animationFrameRef.current);
+      }
+
+      const progressBar = progressRefs.current[index];
+      progressBar.style.transition = "none";
+      progressBar.style.transform = "scaleX(0)";
+
+      const easeInOut = (t: number): number => {
+        return -(Math.cos(Math.PI * t) - 1) / 2;
+      };
+
+      setTimeout(() => {
+        let startTime: number | null = null;
+
+        const animate = (timestamp: number) => {
+          if (!startTime) startTime = timestamp;
+          const elapsed = timestamp - startTime;
+          const linearProgress = Math.min(elapsed / ANIMATION_CONFIG.PROGRESS_DURATION, 1);
+          const easedProgress = easeInOut(linearProgress);
+
+          if (progressRefs.current[index]) {
+            progressRefs.current[index]!.style.transform = `scaleX(${easedProgress})`;
+          }
+
+          if (linearProgress < 1) {
+            animationFrameRef.current = requestAnimationFrame(animate);
+          } else {
+            setActiveIndex((prevIndex) => {
+              const nextIndex = prevIndex + 1;
+              if (nextIndex >= itemCount) {
+                resetAllProgressBars();
+                return 0;
+              }
+              return nextIndex;
+            });
+          }
+        };
+
+        animationFrameRef.current = requestAnimationFrame(animate);
+      }, ANIMATION_CONFIG.ANIMATION_START_DELAY);
+    },
+    [itemCount, resetAllProgressBars]
+  );
+
+  useEffect(() => {
+    for (let i = 0; i < activeIndex; i++) {
+      const bar = progressRefs.current[i];
+      if (bar) {
+        bar.style.transform = "scaleX(1)";
+      }
+    }
+
+    if (isMountedRef.current) {
+      animateProgress(activeIndex);
+    }
+
+    return () => {
+      if (animationFrameRef.current) {
+        cancelAnimationFrame(animationFrameRef.current);
+        animationFrameRef.current = null;
+      }
+    };
+  }, [activeIndex, animateProgress]);
+
+  useEffect(() => {
+    isMountedRef.current = true;
+
+    if (!hasInitializedRef.current) {
+      hasInitializedRef.current = true;
+
+      if (mediaItems && mediaItems[0]) {
+        setCurrentMediaSrc({
+          imageSrc: mediaItems[0].imageSrc,
+          videoSrc: mediaItems[0].videoSrc,
+        });
+        setImageOpacity(1);
+      }
+
+      setTimeout(() => {
+        if (isMountedRef.current) {
+          animateProgress(0);
+        }
+      }, ANIMATION_CONFIG.ANIMATION_START_DELAY);
+    }
+
+    return () => {
+      isMountedRef.current = false;
+      if (animationFrameRef.current) {
+        cancelAnimationFrame(animationFrameRef.current);
+        animationFrameRef.current = null;
+      }
+      if (imageTransitionTimeoutRef.current) {
+        clearTimeout(imageTransitionTimeoutRef.current);
+        imageTransitionTimeoutRef.current = null;
+      }
+    };
+  }, [animateProgress, mediaItems]);
+
+  useEffect(() => {
+    if (!isMountedRef.current || !mediaItems) return;
+
+    const currentItem = mediaItems[activeIndex];
+    if (!currentItem) return;
+
+    const newMediaSrc = {
+      imageSrc: currentItem.imageSrc,
+      videoSrc: currentItem.videoSrc,
+    };
+
+    if (
+      (newMediaSrc.imageSrc && newMediaSrc.imageSrc !== currentMediaSrc.imageSrc) ||
+      (newMediaSrc.videoSrc && newMediaSrc.videoSrc !== currentMediaSrc.videoSrc)
+    ) {
+      if (imageTransitionTimeoutRef.current) {
+        clearTimeout(imageTransitionTimeoutRef.current);
+      }
+
+      setImageOpacity(0);
+
+      imageTransitionTimeoutRef.current = setTimeout(() => {
+        if (isMountedRef.current) {
+          setCurrentMediaSrc(newMediaSrc);
+          setTimeout(() => {
+            if (isMountedRef.current) {
+              setImageOpacity(1);
+            }
+          }, 50);
+        }
+      }, ANIMATION_CONFIG.IMAGE_TRANSITION_DELAY);
+    }
+
+    return () => {
+      if (imageTransitionTimeoutRef.current) {
+        clearTimeout(imageTransitionTimeoutRef.current);
+      }
+    };
+  }, [activeIndex, mediaItems, currentMediaSrc]);
+
+  const handleImageLoad = useCallback(() => {
+    setImageOpacity(1);
+  }, []);
+
+  const handleItemClick = useCallback(
+    (index: number) => {
+      if (index === activeIndex) return;
+
+      if (animationFrameRef.current) {
+        cancelAnimationFrame(animationFrameRef.current);
+      }
+
+      for (let i = 0; i < index; i++) {
+        const bar = progressRefs.current[i];
+        if (bar) {
+          bar.style.transition = `transform ${ANIMATION_CONFIG.TRANSITION_DURATION}ms ease-in-out`;
+          bar.style.transform = "scaleX(1)";
+        }
+      }
+
+      for (let i = index; i < progressRefs.current.length; i++) {
+        const bar = progressRefs.current[i];
+        if (bar) {
+          bar.style.transition = `transform ${ANIMATION_CONFIG.TRANSITION_DURATION}ms ease-in-out`;
+          bar.style.transform = "scaleX(0)";
+        }
+      }
+
+      setActiveIndex(index);
+    },
+    [activeIndex]
+  );
+
+  return {
+    activeIndex,
+    progressRefs,
+    handleItemClick,
+    imageOpacity,
+    currentMediaSrc,
+    handleImageLoad,
+  };
+};