Test 2

import { useCallback, useEffect, useRef, useState } from "react";

import NumberFlow from "@number-flow/react";
import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";

import { cn } from "@/lib/utils";

type Frame = {
    id: string;
    src: string;
    year: number;
    title: string;
};

const photo = (id: string) => `https://images.unsplash.com/${id}?q=80&w=1200&auto=format&fit=crop`;

const SCENES: Array<[string, number, string]> = [
    ["photo-1506905925346-21bda4d32df4", 1996, "Alpine Dawn"],
    ["photo-1469474968028-56623f02e42e", 1997, "Emerald Valley"],
    ["photo-1441974231531-c6227db76b6e", 1998, "Redwood Silence"],
    ["photo-1470071459604-3b5ec3a7fe05", 1999, "Fog Line"],
    ["photo-1501594907352-04cda38ebc29", 2000, "Stillwater Lake"],
    ["photo-1519681393784-d120267933ba", 2001, "Midnight Ascent"],
    ["photo-1507525428034-b723cf961d3e", 2002, "Coral Shore"],
    ["photo-1518837695005-2083093ee35b", 2003, "Breaker"],
    ["photo-1476514525535-07fb3b4ae5f1", 2004, "North Canoe"],
    ["photo-1493246507139-91e8fad9978e", 2005, "Mirror Tarn"],
    ["photo-1472214103451-9374bd1c798e", 2006, "Golden Meadow"],
    ["photo-1433086966358-54859d0ed716", 2007, "Falls Crossing"],
    ["photo-1504893524553-b855bce32c67", 2008, "Rapids"],
    ["photo-1419242902214-272b3f66ee7a", 2009, "Starfield"],
    ["photo-1475924156734-496f6cac6ec1", 2010, "Low Tide"],
    ["photo-1500530855697-b586d89ba3ee", 2011, "Cabin Road"],
    ["photo-1501785888041-af3ef285b470", 2012, "Ember Lake"],
    ["photo-1508739773434-c26b3d09e071", 2013, "Solar Bloom"],
    ["photo-1493976040374-85c8e12f0c0e", 2014, "Kyoto Lanterns"],
    ["photo-1570077188670-e3a8d69ac5ff", 2015, "Aegean Blue"],
    ["photo-1530122037265-a5f1f91d3b99", 2016, "High Alps"],
    ["photo-1495616811223-4d98c6e9c869", 2017, "Cloud Sea"],
    ["photo-1514565131-fce0801e5785", 2018, "Metro Grid"],
    ["photo-1449824913935-59a10b8d2000", 2019, "Fifth Avenue"],
    ["photo-1480714378408-67cf0d13bc1b", 2020, "Skyline Rush"],
    ["photo-1519501025264-65ba15a82390", 2021, "Neon District"],
    ["photo-1502602898657-3e91760cbb34", 2022, "Paris Lights"],
    ["photo-1513635269975-59663e0ac1ad", 2023, "London Rain"],
    ["photo-1542931287-023b922fa89b", 2024, "Tokyo Drift"],
    ["photo-1499092346589-b9b6be3e94b2", 2025, "Times Square"],
];

const FRAMES: Frame[] = SCENES.map(([id, year, title]) => ({ id, src: photo(id), year, title }));

const LAST = FRAMES.length - 1;
const START = Math.round(LAST / 2);
// Frames kept mounted on either side of the current still, so the dolly
// has a real before/after pose to transition between.
const DEPTH = 4;
// Outer thirds are the sustained direction. The center holds.
const EDGE = 0.33;
const PX_PER_FRAME = 48;
const GRAIN = `url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="180" height="180"><filter id="n"><feTurbulence type="fractalNoise" baseFrequency="0.85" numOctaves="2" stitchTiles="stitch"/></filter><rect width="180" height="180" filter="url(%23n)" opacity="0.55"/></svg>')`;
const EASE = "cubic-bezier(0.32, 0.72, 0, 1)";
const TRANSITION = `transform 0.52s ${EASE}, opacity 0.52s ${EASE}`;

const clamp = (value: number, min: number, max: number) => Math.min(max, Math.max(min, value));
const clampFrame = (value: number) => clamp(value, 0, LAST);

// Negative offset has already passed the camera (larger). Positive offset
// is still ahead, down the tunnel (smaller). Offset 0 fills the frame.
const pose = (offset: number) => {
    const away = Math.abs(offset);
    const scale = offset > 0 ? Math.max(0.7, 1 - away * 0.14) : Math.min(1.28, 1 + away * 0.16);
    let zIndex = 20;
    if (offset < 0) zIndex = 30 - away;
    if (offset > 0) zIndex = 10 - away;
    return {
        transform: `scale(${scale.toFixed(4)})`,
        opacity: offset === 0 ? 1 : 0,
        zIndex,
    };
};

// Right is the future, left is the past. Magnitude grows toward the edge.
const cruiseRate = (t: number) => {
    if (t >= 1 - EDGE) return 1 + ((t - (1 - EDGE)) / EDGE) * 1.35;
    if (t <= EDGE) return -(1 + ((EDGE - t) / EDGE) * 1.35);
    return 0;
};

export const Demo = () => {
    const [index, setIndex] = useState(START);
    const [hovering, setHovering] = useState(false);
    const [indicated, setIndicated] = useState(0);
    const [ready, setReady] = useState(false);
    const [reduce, setReduce] = useState(false);
    const [engaged, setEngaged] = useState(false);

    const indexRef = useRef(START);
    const pendingRef = useRef(0);
    const cruiseRef = useRef(0);
    const hoveringRef = useRef(false);
    const indicatedRef = useRef(0);
    const engagedRef = useRef(false);
    const lastXRef = useRef<number | null>(null);
    const lastMoveRef = useRef(0);
    const lastKeyRef = useRef(0);

    const frame = FRAMES[index];

    const showDirection = (dir: number) => {
        if (dir === indicatedRef.current) return;
        indicatedRef.current = dir;
        setIndicated(dir);
    };

    const kick = () => {
        if (engagedRef.current) return;
        engagedRef.current = true;
        setEngaged(true);
    };

    const step = useCallback((dir: 1 | -1) => {
        const next = clampFrame(indexRef.current + dir);
        if (next === indexRef.current) return false;
        indexRef.current = next;
        setIndex(next);
        return true;
    }, []);

    useEffect(() => {
        const id = requestAnimationFrame(() => setReady(true));
        return () => cancelAnimationFrame(id);
    }, []);

    useEffect(() => {
        const media = window.matchMedia("(prefers-reduced-motion: reduce)");
        const apply = () => setReduce(media.matches);
        apply();
        media.addEventListener("change", apply);
        return () => media.removeEventListener("change", apply);
    }, []);

    useEffect(() => {
        if (!engaged || reduce) return;

        let raf = 0;
        let alive = true;
        let last = performance.now();
        let since = 0;

        const tick = (now: number) => {
            if (!alive) return;
            const dt = Math.min(0.05, (now - last) / 1000);
            last = now;

            const still = now - lastMoveRef.current > 140;
            if (hoveringRef.current && still && Math.abs(pendingRef.current) < 1) {
                pendingRef.current = clamp(pendingRef.current + cruiseRef.current * dt, -12, 12);
            }

            const pending = pendingRef.current;
            if (Math.abs(pending) >= 1) {
                since += dt;
                const backlog = Math.abs(pending);
                const interval = backlog > 5 ? 0.2 : backlog > 2 ? 0.3 : 0.46;
                if (since >= interval) {
                    since = 0;
                    const dir = pending > 0 ? 1 : -1;
                    if (step(dir)) pendingRef.current -= dir;
                    else pendingRef.current = 0;
                }
            } else {
                since = 0;
            }

            const nextPending = pendingRef.current;
            const dirNow =
                Math.abs(nextPending) >= 0.75
                    ? Math.sign(nextPending)
                    : hoveringRef.current
                      ? Math.sign(cruiseRef.current)
                      : 0;
            showDirection(dirNow);

            if (hoveringRef.current || Math.abs(pendingRef.current) >= 1) {
                raf = requestAnimationFrame(tick);
                return;
            }

            engagedRef.current = false;
            setEngaged(false);
        };

        raf = requestAnimationFrame(tick);
        return () => {
            alive = false;
            cancelAnimationFrame(raf);
        };
    }, [engaged, reduce, step]);

    const readPointer = (event: React.PointerEvent<HTMLDivElement>) => {
        const rect = event.currentTarget.getBoundingClientRect();
        const x = event.clientX - rect.left;
        const t = clamp(rect.width > 0 ? x / rect.width : 0.5, 0, 1);
        const previous = lastXRef.current;
        lastXRef.current = x;

        if (previous !== null) {
            const dx = x - previous;
            // Left → right queues the future. Right → left queues the past.
            if (Math.abs(dx) > 0.5) {
                pendingRef.current = clamp(pendingRef.current + dx / PX_PER_FRAME, -12, 12);
                lastMoveRef.current = performance.now();
            }
        }

        cruiseRef.current = reduce ? 0 : cruiseRate(t);
        const dir = Math.abs(pendingRef.current) >= 0.75 ? Math.sign(pendingRef.current) : Math.sign(cruiseRef.current);
        showDirection(dir);
        if (!reduce) kick();
    };

    const onPointerEnter = (event: React.PointerEvent<HTMLDivElement>) => {
        hoveringRef.current = true;
        lastXRef.current = null;
        lastMoveRef.current = performance.now();
        setHovering(true);
        readPointer(event);
    };

    const onPointerLeave = () => {
        hoveringRef.current = false;
        cruiseRef.current = 0;
        lastXRef.current = null;
        setHovering(false);
        if (Math.abs(pendingRef.current) < 1) showDirection(0);
    };

    const onKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
        if (event.key !== "ArrowRight" && event.key !== "ArrowLeft") return;
        event.preventDefault();
        const now = performance.now();
        if (now - lastKeyRef.current < 260) return;
        lastKeyRef.current = now;
        const dir = event.key === "ArrowRight" ? 1 : -1;
        if (!step(dir)) return;
        showDirection(dir);
        window.setTimeout(() => {
            if (!hoveringRef.current && Math.abs(pendingRef.current) < 1) showDirection(0);
        }, 640);
    };

    const onPointerUp = (event: React.PointerEvent<HTMLDivElement>) => {
        if (!reduce) return;
        const rect = event.currentTarget.getBoundingClientRect();
        const t = clamp((event.clientX - rect.left) / (rect.width || 1), 0, 1);
        const dir = t < 0.5 ? -1 : 1;
        if (!step(dir)) return;
        showDirection(dir);
    };

    const hintsOn = hovering || indicated !== 0;
    const pastStrength = !hintsOn ? 0 : indicated < 0 ? 1 : indicated > 0 ? 0.28 : index > 0 ? 0.72 : 0.32;
    const futureStrength = !hintsOn ? 0 : indicated > 0 ? 1 : indicated < 0 ? 0.28 : index < LAST ? 0.72 : 0.32;

    const stills = [];
    for (let i = index - DEPTH; i <= index + DEPTH; i++) {
        if (i < 0 || i > LAST) continue;
        const offset = i - index;
        const shot = FRAMES[i];
        stills.push(
            <div
                key={shot.id}
                className={cn("absolute inset-0", Math.abs(offset) <= 1 && "will-change-transform")}
                style={{
                    ...pose(offset),
                    transition: ready && !reduce ? TRANSITION : "none",
                }}>
                <img
                    src={shot.src}
                    alt={offset === 0 ? `${shot.title}, ${shot.year}` : ""}
                    aria-hidden={offset !== 0}
                    width={1200}
                    height={750}
                    draggable={false}
                    decoding="async"
                    fetchPriority={offset === 0 ? "high" : "auto"}
                    loading={Math.abs(offset) <= 2 ? "eager" : "lazy"}
                    className="h-full w-full object-cover"
                />
            </div>,
        );
    }

    return (
        <div className="mx-auto w-full max-w-3xl">
            <div
                role="slider"
                tabIndex={0}
                aria-label="Photo timeline. Move right for the future, left for the past."
                aria-valuemin={FRAMES[0].year}
                aria-valuemax={FRAMES[LAST].year}
                aria-valuenow={frame.year}
                aria-valuetext={`${frame.title}, ${frame.year}`}
                aria-orientation="horizontal"
                data-year={frame.year}
                onPointerEnter={onPointerEnter}
                onPointerMove={readPointer}
                onPointerLeave={onPointerLeave}
                onPointerUp={onPointerUp}
                onKeyDown={onKeyDown}
                className={cn(
                    "relative aspect-[16/10] w-full touch-none overflow-hidden rounded-md bg-black select-none",
                    "ring-foreground/10 ring-1 outline-none",
                    "focus-visible:ring-2 focus-visible:ring-white/80 focus-visible:ring-offset-2 focus-visible:ring-offset-black",
                    hovering ? "cursor-ew-resize" : "cursor-default",
                )}>
                {stills}

                <div
                    className="pointer-events-none absolute inset-0 z-40 opacity-[0.1] mix-blend-overlay"
                    style={{ backgroundImage: GRAIN }}
                />
                <div className="pointer-events-none absolute inset-0 z-40 bg-[radial-gradient(ellipse_at_center,transparent_50%,rgba(0,0,0,0.42)_100%)]" />

                <div
                    className="pointer-events-none absolute inset-y-0 left-0 z-40 w-2/5 bg-gradient-to-r from-black/55 to-transparent transition-opacity duration-300"
                    style={{ opacity: pastStrength }}
                />
                <div
                    className="pointer-events-none absolute inset-y-0 right-0 z-40 w-2/5 bg-gradient-to-l from-black/55 to-transparent transition-opacity duration-300"
                    style={{ opacity: futureStrength }}
                />

                <div
                    className="pointer-events-none absolute top-1/2 left-3 z-50 flex -translate-y-1/2 items-center gap-1 text-white drop-shadow-[0_1px_8px_rgba(0,0,0,0.65)] transition-opacity duration-300 sm:left-4"
                    style={{ opacity: pastStrength }}>
                    <ChevronLeftIcon
                        className={cn("size-4 transition-transform duration-500", indicated < 0 && "-translate-x-1")}
                        aria-hidden
                    />
                    <span className="text-[10px] font-medium tracking-[0.22em] uppercase sm:text-[11px]">Past</span>
                </div>
                <div
                    className="pointer-events-none absolute top-1/2 right-3 z-50 flex -translate-y-1/2 items-center gap-1 text-white drop-shadow-[0_1px_8px_rgba(0,0,0,0.65)] transition-opacity duration-300 sm:right-4"
                    style={{ opacity: futureStrength }}>
                    <span className="text-[10px] font-medium tracking-[0.22em] uppercase sm:text-[11px]">Future</span>
                    <ChevronRightIcon
                        className={cn("size-4 transition-transform duration-500", indicated > 0 && "translate-x-1")}
                        aria-hidden
                    />
                </div>

                <div className="pointer-events-none absolute inset-x-0 bottom-0 z-50 bg-gradient-to-t from-black/75 via-black/30 to-transparent px-4 pt-16 pb-3 text-white">
                    <div className="flex items-end justify-between gap-4">
                        <p className="truncate text-sm font-medium tracking-wide">{frame.title}</p>
                        <NumberFlow
                            value={frame.year}
                            format={{ useGrouping: false }}
                            className="font-mono text-2xl font-semibold tabular-nums"
                        />
                    </div>
                    <div className="relative mt-2.5 h-px w-full bg-white/25">
                        <div
                            className="absolute top-1/2 size-1.5 -translate-x-1/2 -translate-y-1/2 rounded-full bg-white shadow-[0_0_10px_rgba(255,255,255,0.85)]"
                            style={{
                                left: `${(index / LAST) * 100}%`,
                                transition: ready && !reduce ? `left 0.46s ${EASE}` : "none",
                            }}
                        />
                    </div>
                </div>
            </div>
        </div>
    );
};