[V0_FILE]typescript:file="lib/supabase/client.ts" isFixed="true" isQuickEdit="true" isMerged="true" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" // Check if Supabase environment variables are available export const isSupabaseConfigured = typeof process.env.NEXT_PUBLIC_SUPABASE_URL === "string" && process.env.NEXT_PUBLIC_SUPABASE_URL.length > 0 && typeof process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY === "string" && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY.length > 0 // Create a singleton instance of the Supabase client for Client Components export const supabase = createClientComponentClient() [V0_FILE]typescriptreact:file="components/signup-form.tsx" isMerged="true" "use client" import { useActionState } from "react" import { useFormStatus } from "react-dom" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Loader2 } from "lucide-react" import Link from "next/link" import { signUp } from "@/lib/actions" function SubmitButton() { const { pending } = useFormStatus() return ( ) } export default function SignUpForm() { // Initialize with null as the initial state const [state, formAction] = useActionState(signUp, null) return (

Create an account

) } [V0_FILE]typescriptreact:file="components/login-form.tsx" isMerged="true" "use client" import { useActionState } from "react" import { useFormStatus } from "react-dom" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Loader2 } from "lucide-react" import Link from "next/link" import { useRouter } from "next/navigation" import { useEffect } from "react" import { signIn } from "@/lib/actions" function SubmitButton() { const { pending } = useFormStatus() return ( ) } export default function LoginForm() { const router = useRouter() const [state, formAction] = useActionState(signIn, null) // Handle successful login by redirecting useEffect(() => { if (state?.success) { router.push("/") } }, [state, router]) return (

Welcome back

) } [V0_FILE]typescript:file="lib/supabase/middleware.ts" isMerged="true" import { createMiddlewareClient } from "@supabase/auth-helpers-nextjs" import { NextResponse, type NextRequest } from "next/server" // Check if Supabase environment variables are available export const isSupabaseConfigured = typeof process.env.NEXT_PUBLIC_SUPABASE_URL === "string" && process.env.NEXT_PUBLIC_SUPABASE_URL.length > 0 && typeof process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY === "string" && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY.length > 0 export async function updateSession(request: NextRequest) { // If Supabase is not configured, just continue without auth if (!isSupabaseConfigured) { return NextResponse.next({ request, }) } const res = NextResponse.next() // Create a Supabase client configured to use cookies const supabase = createMiddlewareClient({ req: request, res }) // Check if this is an auth callback const requestUrl = new URL(request.url) const code = requestUrl.searchParams.get("code") if (code) { // Exchange the code for a session await supabase.auth.exchangeCodeForSession(code) // Redirect to home page after successful auth return NextResponse.redirect(new URL("/", request.url)) } // Refresh session if expired - required for Server Components await supabase.auth.getSession() // Protected routes - redirect to login if not authenticated const isAuthRoute = request.nextUrl.pathname.startsWith("/auth/login") || request.nextUrl.pathname.startsWith("/auth/sign-up") || request.nextUrl.pathname === "/auth/callback" if (!isAuthRoute) { const { data: { session }, } = await supabase.auth.getSession() if (!session) { const redirectUrl = new URL("/auth/login", request.url) return NextResponse.redirect(redirectUrl) } } return res } [V0_FILE]typescript:file="lib/supabase/server.ts" isMerged="true" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { cache } from "react" // Check if Supabase environment variables are available export const isSupabaseConfigured = typeof process.env.NEXT_PUBLIC_SUPABASE_URL === "string" && process.env.NEXT_PUBLIC_SUPABASE_URL.length > 0 && typeof process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY === "string" && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY.length > 0 // Create a cached version of the Supabase client for Server Components export const createClient = cache(() => { const cookieStore = cookies() if (!isSupabaseConfigured) { console.warn("Supabase environment variables are not set. Using dummy client.") return { auth: { getUser: () => Promise.resolve({ data: { user: null }, error: null }), getSession: () => Promise.resolve({ data: { session: null }, error: null }), }, } } return createServerComponentClient({ cookies: () => cookieStore }) }) [V0_FILE]typescript:file="lib/actions.ts" isMerged="true" "use server" import { createServerActionClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { redirect } from "next/navigation" // Update the signIn function to handle redirects properly export async function signIn(prevState: any, formData: FormData) { // Check if formData is valid if (!formData) { return { error: "Form data is missing" } } const email = formData.get("email") const password = formData.get("password") // Validate required fields if (!email || !password) { return { error: "Email and password are required" } } const cookieStore = cookies() const supabase = createServerActionClient({ cookies: () => cookieStore }) try { const { error } = await supabase.auth.signInWithPassword({ email: email.toString(), password: password.toString(), }) if (error) { return { error: error.message } } // Return success instead of redirecting directly return { success: true } } catch (error) { console.error("Login error:", error) return { error: "An unexpected error occurred. Please try again." } } } // Update the signUp function to handle potential null formData export async function signUp(prevState: any, formData: FormData) { // Check if formData is valid if (!formData) { return { error: "Form data is missing" } } const email = formData.get("email") const password = formData.get("password") // Validate required fields if (!email || !password) { return { error: "Email and password are required" } } const cookieStore = cookies() const supabase = createServerActionClient({ cookies: () => cookieStore }) try { const { error } = await supabase.auth.signUp({ email: email.toString(), password: password.toString(), }) if (error) { return { error: error.message } } return { success: "Check your email to confirm your account." } } catch (error) { console.error("Sign up error:", error) return { error: "An unexpected error occurred. Please try again." } } } export async function signOut() { const cookieStore = cookies() const supabase = createServerActionClient({ cookies: () => cookieStore }) await supabase.auth.signOut() redirect("/auth/login") } [V0_FILE]typescript:file="app/auth/login/page.tsx" isMerged="true" import { createClient, isSupabaseConfigured } from "@/lib/supabase/server" import { redirect } from "next/navigation" import LoginForm from "@/components/login-form" export default async function LoginPage() { // If Supabase is not configured, show setup message directly if (!isSupabaseConfigured) { return (

Connect Supabase to get started

) } // Check if user is already logged in const supabase = createClient() const { data: { session }, } = await supabase.auth.getSession() // If user is logged in, redirect to home page if (session) { redirect("/") } return (

) } [V0_FILE]typescript:file="app/auth/sign-up/page.tsx" isMerged="true" import { createClient, isSupabaseConfigured } from "@/lib/supabase/server" import { redirect } from "next/navigation" import SignUpForm from "@/components/signup-form" export default async function SignUpPage() { // If Supabase is not configured, show setup message directly if (!isSupabaseConfigured) { return (

Connect Supabase to get started

) } [V0_FILE]typescriptreact:file="app/blog/page.tsx" isMerged="true" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Button } from "@/components/ui/button" import { Calendar, User, ArrowRight } from "lucide-react" import Image from "next/image" const blogPosts = [ { id: 1, title: "Periodización en Deportes de Equipo: Guía Completa 2024", excerpt: "Descubre las últimas metodologías de periodización aplicadas a deportes colectivos y cómo optimizar el rendimiento durante toda la temporada.", author: "Dr. Carlos Martínez", date: "15 Enero 2024", category: "Metodología", image: "/placeholder.svg?height=200&width=400", readTime: "8 min", }, { id: 2, title: "Análisis Biomecánico del Salto Vertical: CMJ vs SJ", excerpt: "Comparativa detallada entre Counter Movement Jump y Squat Jump, interpretación de resultados y aplicaciones prácticas.", author: "Dra. Ana López", date: "12 Enero 2024", category: "Biomecánica", image: "/placeholder.svg?height=200&width=400", readTime: "12 min", }, { id: 3, title: "Entrenamiento de Fuerza en Jóvenes Atletas", excerpt: "Protocolos seguros y efectivos para el desarrollo de la fuerza en deportistas en edad de crecimiento.", author: "Prof. Miguel Rodríguez", date: "10 Enero 2024", category: "Entrenamiento", image: "/placeholder.svg?height=200&width=400", readTime: "10 min", }, { id: 4, title: "Tecnología en el Análisis del Rendimiento Deportivo", excerpt: "Herramientas digitales y dispositivos de medición que están revolucionando el análisis deportivo moderno.", author: "Ing. Laura García", date: "8 Enero 2024", category: "Tecnología", image: "/placeholder.svg?height=200&width=400", readTime: "6 min", }, { id: 5, title: "Prevención de Lesiones a través del Análisis de Movimiento", excerpt: "Cómo identificar patrones de riesgo y implementar estrategias preventivas basadas en datos objetivos.", author: "Dr. Roberto Silva", date: "5 Enero 2024", category: "Prevención", image: "/placeholder.svg?height=200&width=400", readTime: "15 min", }, { id: 6, title: "Nutrición Deportiva: Timing y Composición de Macronutrientes", excerpt: "Estrategias nutricionales específicas para optimizar el rendimiento y la recuperación en atletas de alto nivel.", author: "Lic. Patricia Morales", date: "3 Enero 2024", category: "Nutrición", image: "/placeholder.svg?height=200&width=400", readTime: "9 min", }, ] const categories = ["Todos", "Metodología", "Biomecánica", "Entrenamiento", "Tecnología", "Prevención", "Nutrición"] export default function BlogPage() { return (

{/* Header */}

Blog de Entrenamiento

Artículos especializados sobre ciencias del deporte, metodología de entrenamiento y análisis del rendimiento

{/* Categories Filter */}

{categories.map((category) => ( {category} ))}

{/* Featured Article */}

Destacado

{blogPosts[0].title}

{blogPosts[0].excerpt}

{blogPosts[0].author}

{blogPosts[0].date}

{blogPosts[0].category}

{/* Articles Grid */}

{blogPosts.slice(1).map((post) => (

{post.category}

{post.title} {post.excerpt}

{post.author}

{post.date}

{post.readTime} lectura

))}

{/* Load More */}

) } [V0_FILE]typescriptreact:file="app/herramientas/page.tsx" isMerged="true" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Download, FileText, Calculator, BarChart, Search, Filter } from "lucide-react" const tools = [ { id: 1, name: "Plantilla de Periodización Anual", description: "Plantilla completa en Excel para planificar toda la temporada deportiva con macrociclos, mesociclos y microciclos.", category: "Planificación", type: "Excel", downloads: 1250, icon: FileText, size: "2.3 MB", }, { id: 2, name: "Calculadora de 1RM", description: "Herramienta para calcular el 1RM basado en diferentes fórmulas validadas científicamente.", category: "Calculadoras", type: "Excel", downloads: 890, icon: Calculator, size: "1.1 MB", }, { id: 3, name: "Análisis de Carga de Entrenamiento", description: "Plantilla para monitorear y analizar la carga interna y externa de entrenamiento.", category: "Análisis", type: "Excel", downloads: 756, icon: BarChart, size: "3.2 MB", }, { id: 4, name: "Guía de Evaluación Física", description: "Manual completo con protocolos de evaluación física para diferentes deportes y poblaciones.", category: "Evaluación", type: "PDF", downloads: 2100, icon: FileText, size: "8.5 MB", }, { id: 5, name: "Calculadora de Potencia Anaeróbica", description: "Herramienta para calcular potencia anaeróbica basada en diferentes tests de campo.", category: "Calculadoras", type: "Excel", downloads: 445, icon: Calculator, size: "1.8 MB", }, { id: 6, name: "Plantilla de Seguimiento Nutricional", description: "Registro completo para el seguimiento de la ingesta nutricional de atletas.", category: "Nutrición", type: "Excel", downloads: 623, icon: FileText, size: "2.1 MB", }, { id: 7, name: "Análisis de Saltos Verticales", description: "Plantilla especializada para analizar datos de CMJ, SJ, DJ y calcular métricas derivadas.", category: "Análisis", type: "Excel", downloads: 1890, icon: BarChart, size: "4.2 MB", }, { id: 8, name: "Protocolo de Calentamiento Dinámico", description: "Guía visual con ejercicios de calentamiento específicos por deporte y posición.", category: "Entrenamiento", type: "PDF", downloads: 1340, icon: FileText, size: "12.3 MB", }, ] const categories = ["Todas", "Planificación", "Calculadoras", "Análisis", "Evaluación", "Nutrición", "Entrenamiento"] export default function HerramientasPage() { return (

{/* Header */}

Herramientas Gratuitas

Recursos descargables para optimizar tu trabajo como entrenador: plantillas, calculadoras y guías especializadas

{/* Search and Filter */}

{/* Categories */}

{categories.map((category) => ( {category} ))}

{/* Stats */}

9,293

Descargas totales

{tools.length}

Herramientas disponibles

100%

Gratuitas

{/* Tools Grid */}

{tools.map((tool) => (

{tool.category}

{tool.type}

{tool.name} {tool.description}

{tool.downloads.toLocaleString()} descargas {tool.size}

))}

{/* CTA Section */}

¿Necesitas una herramienta específica?

Contáctanos y desarrollaremos la herramienta que necesitas para tu trabajo

) } [V0_FILE]typescriptreact:file="app/herramientas/loading.tsx" isFixed="true" isMerged="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="app/planes/page.tsx" isMerged="true" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Star, Clock, Users, Target, Search, Filter, ShoppingCart } from "lucide-react" import Image from "next/image" const plans = [ { id: 1, title: "Fuerza Funcional para Principiantes", description: "Programa de 12 semanas diseñado para desarrollar una base sólida de fuerza funcional en atletas novatos.", image: "/placeholder.svg?height=200&width=300", price: 49.99, originalPrice: 79.99, difficulty: "Principiante", duration: "12 semanas", sessions: 36, rating: 4.8, reviews: 124, category: "Fuerza", features: ["Plan detallado día a día", "Videos explicativos", "Progresiones adaptables", "Soporte por email"], }, { id: 2, title: "Potencia Explosiva Avanzada", description: "Entrenamiento especializado para desarrollar potencia explosiva en atletas de alto rendimiento.", image: "/placeholder.svg?height=200&width=300", price: 89.99, originalPrice: 129.99, difficulty: "Avanzado", duration: "16 semanas", sessions: 64, rating: 4.9, reviews: 87, category: "Potencia", features: ["Análisis biomecánico", "Periodización avanzada", "Tests de evaluación", "Seguimiento personalizado"], }, { id: 3, title: "Acondicionamiento para Deportes de Equipo", description: "Programa integral de acondicionamiento físico específico para deportes colectivos.", image: "/placeholder.svg?height=200&width=300", price: 69.99, originalPrice: 99.99, difficulty: "Intermedio", duration: "20 semanas", sessions: 80, rating: 4.7, reviews: 156, category: "Acondicionamiento", features: [ "Trabajo específico por posición", "Prevención de lesiones", "Planificación estacional", "Nutrición deportiva", ], }, { id: 4, title: "Rehabilitación y Readaptación", description: "Protocolo completo para la vuelta al deporte después de lesiones musculoesqueléticas.", image: "/placeholder.svg?height=200&width=300", price: 79.99, originalPrice: 119.99, difficulty: "Intermedio", duration: "14 semanas", sessions: 42, rating: 4.9, reviews: 93, category: "Rehabilitación", features: ["Evaluación funcional", "Progresión gradual", "Ejercicios correctivos", "Criterios de alta"], }, { id: 5, title: "Entrenamiento de Velocidad y Agilidad", description: "Desarrollo sistemático de la velocidad lineal y multidireccional para atletas jóvenes.", image: "/placeholder.svg?height=200&width=300", price: 59.99, originalPrice: 89.99, difficulty: "Principiante", duration: "10 semanas", sessions: 30, rating: 4.6, reviews: 201, category: "Velocidad", features: ["Técnica de carrera", "Cambios de dirección", "Reactividad", "Tests de velocidad"], }, { id: 6, title: "Preparación Física para Mujeres Atletas", description: "Programa especializado considerando las características fisiológicas específicas de atletas femeninas.", image: "/placeholder.svg?height=200&width=300", price: 74.99, originalPrice: 109.99, difficulty: "Intermedio", duration: "18 semanas", sessions: 54, rating: 4.8, reviews: 78, category: "Especializado", features: ["Consideraciones hormonales", "Prevención específica", "Fuerza del core", "Salud ósea"], }, ] const difficulties = ["Todos", "Principiante", "Intermedio", "Avanzado"] const categories = ["Todas", "Fuerza", "Potencia", "Acondicionamiento", "Rehabilitación", "Velocidad", "Especializado"] export default function PlanesPage() { return (

{/* Header */}

Planes de Entrenamiento

Programas completos diseñados por expertos para diferentes niveles y objetivos deportivos

{/* Search and Filter */}

{/* Filters */}

Nivel de Dificultad

{difficulties.map((difficulty) => ( {difficulty} ))}

Categoría

{categories.map((category) => ( {category} ))}

{/* Featured Plan */}

Plan Destacado

{plans[1].title}

{plans[1].description}

{plans[1].difficulty}

{plans[1].duration}

{plans[1].sessions} sesiones

{plans[1].rating} ({plans[1].reviews})

${plans[1].price} ${plans[1].originalPrice} -31%

{/* Plans Grid */}

{plans.map((plan) => (

{plan.category} {plan.originalPrice > plan.price && ( -{Math.round((1 - plan.price / plan.originalPrice) * 100)}% )}

{plan.difficulty}

{plan.rating} ({plan.reviews})

{plan.title} {plan.description}

{plan.duration}

{plan.sessions} sesiones

{plan.features.slice(0, 2).map((feature, index) => (

{feature}

))}

${plan.price} {plan.originalPrice > plan.price && ( ${plan.originalPrice} )}

))}

{/* CTA Section */}

¿Necesitas un plan personalizado?

Nuestros expertos pueden crear un programa específico para tus atletas y objetivos

) } [V0_FILE]typescriptreact:file="app/planes/loading.tsx" isFixed="true" isMerged="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="components/team-overview.tsx" isMerged="true" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Progress } from "@/components/ui/progress" interface PlayerData { nombre: string posicion: string cmj: number sj: number dj: number rsi: number tc: number eur?: number zScores?: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface TeamStats { mean: { cmj: number sj: number dj: number rsi: number tc: number eur: number } std: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface TeamOverviewProps { players: PlayerData[] teamStats: TeamStats } export function TeamOverview({ players, teamStats }: TeamOverviewProps) { const positions = [...new Set(players.map((p) => p.posicion))] const getPositionStats = (position: string) => { const positionPlayers = players.filter((p) => p.posicion === position) return { count: positionPlayers.length, avgCMJ: positionPlayers.reduce((sum, p) => sum + p.cmj, 0) / positionPlayers.length, avgRSI: positionPlayers.reduce((sum, p) => sum + p.rsi, 0) / positionPlayers.length, avgEUR: positionPlayers.reduce((sum, p) => sum + (p.eur || 0), 0) / positionPlayers.length, } } return (

{/* Team Statistics */} Estadísticas del Equipo Promedios y desviaciones estándar de todas las métricas

{Object.entries(teamStats.mean).map(([metric, mean]) => (

{metric.toUpperCase()} {mean.toFixed(2)} ± {teamStats.std[metric as keyof typeof teamStats.std].toFixed(2)}

))}

{/* Position Analysis */} Análisis por Posición Comparación de métricas entre diferentes posiciones

{positions.map((position) => { const stats = getPositionStats(position) return (

{position}

{stats.count} jugadores

CMJ Promedio

{stats.avgCMJ.toFixed(1)} cm

RSI Promedio

{stats.avgRSI.toFixed(2)}

EUR Promedio

{stats.avgEUR.toFixed(1)}%

) })}

{/* Top Performers */} Mejores Rendimientos Jugadores destacados en cada métrica

{["cmj", "rsi", "eur"].map((metric) => (

{metric.toUpperCase()}

{players .sort( (a, b) => (b[metric as keyof PlayerData] as number) - (a[metric as keyof PlayerData] as number), ) .slice(0, 3) .map((player, index) => (

{index + 1}

{player.nombre}

{player.posicion}

{(player[metric as keyof PlayerData] as number).toFixed(metric === "eur" ? 1 : 2)} {metric === "eur" ? "%" : metric === "cmj" ? " cm" : ""}

))}

) } [V0_FILE]sql:file="scripts/create-tables.sql" type="inline-sql" transaction="true" name="create-tables.sql" isMerged="true" -- Crear tabla de equipos CREATE TABLE IF NOT EXISTS teams ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, name VARCHAR(255) NOT NULL, sport VARCHAR(100), season VARCHAR(50), description TEXT, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Crear tabla de jugadores CREATE TABLE IF NOT EXISTS players ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, team_id UUID REFERENCES teams(id) ON DELETE CASCADE, name VARCHAR(255) NOT NULL, position VARCHAR(100), jersey_number INTEGER, age INTEGER, height DECIMAL(5,2), weight DECIMAL(5,2), created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Crear tabla de análisis de saltos CREATE TABLE IF NOT EXISTS jump_analyses ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, player_id UUID REFERENCES players(id) ON DELETE CASCADE, team_id UUID REFERENCES teams(id) ON DELETE CASCADE, test_date DATE DEFAULT CURRENT_DATE, cmj DECIMAL(6,2) NOT NULL, sj DECIMAL(6,2) NOT NULL, dj DECIMAL(6,2) NOT NULL, rsi DECIMAL(6,3) NOT NULL, tc DECIMAL(6,4) NOT NULL, eur DECIMAL(6,2), -- Calculado automáticamente notes TEXT, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Crear tabla de estadísticas de equipo (para cache de cálculos) CREATE TABLE IF NOT EXISTS team_statistics ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, team_id UUID REFERENCES teams(id) ON DELETE CASCADE, analysis_date DATE DEFAULT CURRENT_DATE, metric_name VARCHAR(50) NOT NULL, mean_value DECIMAL(10,4), std_value DECIMAL(10,4), min_value DECIMAL(10,4), max_value DECIMAL(10,4), created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), UNIQUE(team_id, analysis_date, metric_name) ); -- Crear índices para mejor rendimiento CREATE INDEX IF NOT EXISTS idx_players_team_id ON players(team_id); CREATE INDEX IF NOT EXISTS idx_jump_analyses_player_id ON jump_analyses(player_id); CREATE INDEX IF NOT EXISTS idx_jump_analyses_team_id ON jump_analyses(team_id); CREATE INDEX IF NOT EXISTS idx_team_statistics_team_id ON team_statistics(team_id); -- Crear función para calcular EUR automáticamente CREATE OR REPLACE FUNCTION calculate_eur() RETURNS TRIGGER AS $$ BEGIN NEW.eur = CASE WHEN NEW.sj > 0 THEN ((NEW.cmj - NEW.sj) / NEW.sj) * 100 ELSE 0 END; NEW.updated_at = NOW(); RETURN NEW; END; $$ LANGUAGE plpgsql; -- Crear trigger para calcular EUR automáticamente DROP TRIGGER IF EXISTS trigger_calculate_eur ON jump_analyses; CREATE TRIGGER trigger_calculate_eur BEFORE INSERT OR UPDATE ON jump_analyses FOR EACH ROW EXECUTE FUNCTION calculate_eur(); -- Crear función para actualizar updated_at CREATE OR REPLACE FUNCTION update_updated_at_column() RETURNS TRIGGER AS $$ BEGIN NEW.updated_at = NOW(); RETURN NEW; END; $$ LANGUAGE plpgsql; -- Crear triggers para updated_at DROP TRIGGER IF EXISTS update_teams_updated_at ON teams; CREATE TRIGGER update_teams_updated_at BEFORE UPDATE ON teams FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); DROP TRIGGER IF EXISTS update_players_updated_at ON players; CREATE TRIGGER update_players_updated_at BEFORE UPDATE ON players FOR EACH ROW EXECUTE FUNCTION update_updated_at_column(); [V0_FILE]png:file="public/logo.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/Sin%20t%C3%ADtulo-1-USOqS2vegGotn6gI6myrxbMnUiZeD4.png" isMerged="true" [V0_FILE]png:file="public/hero-bg-1.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/Untitled-2-XMt3LPK0D4ZYqv7GBfoHCBcqlgaAxb.png" isMerged="true" [V0_FILE]png:file="public/hero-bg-2.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/Untitled-1-HktKUZyI7HbbsowyGlRcG9pRGZYxSJ.png" isMerged="true" [V0_FILE]typescriptreact:file="app/layout.tsx" isEdit="true" isQuickEdit="true" isMerged="true" import type React from "react" import type { Metadata } from "next" import { Inter } from "next/font/google" import "./globals.css" import { SidebarProvider } from "@/components/ui/sidebar" import { AppSidebar } from "@/components/app-sidebar" const inter = Inter({ subsets: ["latin"] }) export const metadata: Metadata = { title: "Agustin Esterman Coach - Análisis Deportivo Profesional", description: "Plataforma especializada en análisis de rendimiento deportivo y entrenamiento de fuerza por Agustin Esterman Coach", } export default function RootLayout({ children, }: { children: React.ReactNode }) { return (

{children}

) } [V0_FILE]typescriptreact:file="tailwind.config.ts" isEdit="true" isMerged="true" import type { Config } from "tailwindcss" const config = { darkMode: ["class"], content: [ "./pages/**/*.{ts,tsx}", "./components/**/*.{ts,tsx}", "./app/**/*.{ts,tsx}", "./src/**/*.{ts,tsx}", "*.{js,ts,jsx,tsx,mdx}", ], prefix: "", theme: { container: { center: true, padding: "2rem", screens: { "2xl": "1400px", }, }, extend: { colors: { border: "hsl(var(--border))", input: "hsl(var(--input))", ring: "hsl(var(--ring))", background: "hsl(var(--background))", foreground: "hsl(var(--foreground))", primary: { DEFAULT: "hsl(var(--primary))", foreground: "hsl(var(--primary-foreground))", }, secondary: { DEFAULT: "hsl(var(--secondary))", foreground: "hsl(var(--secondary-foreground))", }, destructive: { DEFAULT: "hsl(var(--destructive))", foreground: "hsl(var(--destructive-foreground))", }, muted: { DEFAULT: "hsl(var(--muted))", foreground: "hsl(var(--muted-foreground))", }, accent: { DEFAULT: "hsl(var(--accent))", foreground: "hsl(var(--accent-foreground))", }, popover: { DEFAULT: "hsl(var(--popover))", foreground: "hsl(var(--popover-foreground))", }, card: { DEFAULT: "hsl(var(--card))", foreground: "hsl(var(--card-foreground))", }, // Colores personalizados para la marca Agustin Esterman brand: { gold: "#F4D03F", "gold-dark": "#D4AC0D", black: "#1C1C1C", "gray-dark": "#2C2C2C", }, }, borderRadius: { lg: "var(--radius)", md: "calc(var(--radius) - 2px)", sm: "calc(var(--radius) - 4px)", }, keyframes: { "accordion-down": { from: { height: "0" }, to: { height: "var(--radix-accordion-content-height)" }, }, "accordion-up": { from: { height: "var(--radix-accordion-content-height)" }, to: { height: "0" }, }, "fade-in": { "0%": { opacity: "0", transform: "translateY(10px)" }, "100%": { opacity: "1", transform: "translateY(0)" }, }, }, animation: { "accordion-down": "accordion-down 0.2s ease-out", "accordion-up": "accordion-up 0.2s ease-out", "fade-in": "fade-in 0.5s ease-out", }, }, }, plugins: [require("tailwindcss-animate")], } satisfies Config export default config [V0_FILE]sql:file="scripts/seed-sample-data.sql" type="inline-sql" transaction="true" name="seed-sample-data.sql" isMerged="true" -- Insertar equipos de ejemplo INSERT INTO teams (id, name, sport, season, description) VALUES ('550e8400-e29b-41d4-a716-446655440001', 'Club Atlético River Plate', 'Fútbol', '2024', 'Equipo profesional de fútbol'), ('550e8400-e29b-41d4-a716-446655440002', 'Boca Juniors', 'Fútbol', '2024', 'Equipo profesional de fútbol'), ('550e8400-e29b-41d4-a716-446655440003', 'Racing Club', 'Fútbol', '2024', 'Equipo profesional de fútbol') ON CONFLICT (id) DO NOTHING; -- Insertar jugadores de ejemplo para River Plate INSERT INTO players (id, team_id, name, position, jersey_number, age, height, weight) VALUES ('660e8400-e29b-41d4-a716-446655440001', '550e8400-e29b-41d4-a716-446655440001', 'Juan Pérez', 'Delantero', 9, 24, 1.78, 75.5), ('660e8400-e29b-41d4-a716-446655440002', '550e8400-e29b-41d4-a716-446655440001', 'Carlos López', 'Centrocampista', 8, 26, 1.75, 72.0), ('660e8400-e29b-41d4-a716-446655440003', '550e8400-e29b-41d4-a716-446655440001', 'Miguel Torres', 'Defensor', 4, 28, 1.82, 78.0), ('660e8400-e29b-41d4-a716-446655440004', '550e8400-e29b-41d4-a716-446655440001', 'Diego Martín', 'Portero', 1, 30, 1.88, 82.0), ('660e8400-e29b-41d4-a716-446655440005', '550e8400-e29b-41d4-a716-446655440001', 'Andrés Silva', 'Delantero', 11, 22, 1.76, 73.5), ('660e8400-e29b-41d4-a716-446655440006', '550e8400-e29b-41d4-a716-446655440001', 'Roberto García', 'Centrocampista', 6, 25, 1.77, 74.0), ('660e8400-e29b-41d4-a716-446655440007', '550e8400-e29b-41d4-a716-446655440001', 'Fernando Ruiz', 'Defensor', 3, 27, 1.80, 76.5), ('660e8400-e29b-41d4-a716-446655440008', '550e8400-e29b-41d4-a716-446655440001', 'Luis Morales', 'Delantero', 7, 23, 1.74, 71.0) ON CONFLICT (id) DO NOTHING; -- Insertar análisis históricos (8 meses de datos) WITH date_series AS ( SELECT generate_series( '2024-01-15'::date, '2024-08-15'::date, '1 month'::interval )::date AS test_date ), player_data AS ( SELECT p.id as player_id, p.team_id, p.name, p.position, -- Valores base para cada jugador CASE p.name WHEN 'Juan Pérez' THEN 45.2 WHEN 'Carlos López' THEN 41.8 WHEN 'Miguel Torres' THEN 38.9 WHEN 'Diego Martín' THEN 35.6 WHEN 'Andrés Silva' THEN 47.3 WHEN 'Roberto García' THEN 43.1 WHEN 'Fernando Ruiz' THEN 40.2 WHEN 'Luis Morales' THEN 46.8 END as base_cmj, CASE p.name WHEN 'Juan Pérez' THEN 38.1 WHEN 'Carlos López' THEN 36.5 WHEN 'Miguel Torres' THEN 34.2 WHEN 'Diego Martín' THEN 31.8 WHEN 'Andrés Silva' THEN 40.2 WHEN 'Roberto García' THEN 37.8 WHEN 'Fernando Ruiz' THEN 35.1 WHEN 'Luis Morales' THEN 39.6 END as base_sj, CASE p.name WHEN 'Juan Pérez' THEN 42.8 WHEN 'Carlos López' THEN 39.2 WHEN 'Miguel Torres' THEN 36.5 WHEN 'Diego Martín' THEN 33.1 WHEN 'Andrés Silva' THEN 44.1 WHEN 'Roberto García' THEN 40.6 WHEN 'Fernando Ruiz' THEN 37.8 WHEN 'Luis Morales' THEN 43.5 END as base_dj, CASE p.name WHEN 'Juan Pérez' THEN 1.85 WHEN 'Carlos López' THEN 1.72 WHEN 'Miguel Torres' THEN 1.58 WHEN 'Diego Martín' THEN 1.45 WHEN 'Andrés Silva' THEN 1.92 WHEN 'Roberto García' THEN 1.78 WHEN 'Fernando Ruiz' THEN 1.65 WHEN 'Luis Morales' THEN 1.89 END as base_rsi, CASE p.name WHEN 'Juan Pérez' THEN 0.245 WHEN 'Carlos López' THEN 0.268 WHEN 'Miguel Torres' THEN 0.289 WHEN 'Diego Martín' THEN 0.312 WHEN 'Andrés Silva' THEN 0.238 WHEN 'Roberto García' THEN 0.256 WHEN 'Fernando Ruiz' THEN 0.275 WHEN 'Luis Morales' THEN 0.241 END as base_tc FROM players p WHERE p.team_id = '550e8400-e29b-41d4-a716-446655440001' ) INSERT INTO jump_analyses (player_id, team_id, test_date, cmj, sj, dj, rsi, tc, notes) SELECT pd.player_id, pd.team_id, ds.test_date, -- Aplicar variación y tendencia de mejora ROUND( (pd.base_cmj * (1 + (random() - 0.5) * 0.1 + (EXTRACT(month FROM ds.test_date) - 1) * 0.02))::numeric, 1 ) as cmj, ROUND( (pd.base_sj * (1 + (random() - 0.5) * 0.1 + (EXTRACT(month FROM ds.test_date) - 1) * 0.02))::numeric, 1 ) as sj, ROUND( (pd.base_dj * (1 + (random() - 0.5) * 0.1 + (EXTRACT(month FROM ds.test_date) - 1) * 0.02))::numeric, 1 ) as dj, ROUND( (pd.base_rsi * (1 + (random() - 0.5) * 0.1 + (EXTRACT(month FROM ds.test_date) - 1) * 0.02))::numeric, 3 ) as rsi, ROUND( (pd.base_tc * (1 - (random() - 0.5) * 0.1 - (EXTRACT(month FROM ds.test_date) - 1) * 0.01))::numeric, 4 ) as tc, 'Evaluación mensual - ' || TO_CHAR(ds.test_date, 'Month YYYY') as notes FROM date_series ds CROSS JOIN player_data pd ON CONFLICT DO NOTHING; [V0_FILE]typescriptreact:file="middleware.ts" isEdit="true" isMerged="true" import { updateSession } from "@/lib/supabase/middleware" import type { NextRequest } from "next/server" export async function middleware(request: NextRequest) { // Solo aplicar autenticación a rutas específicas const protectedPaths = ["/dashboard", "/herramientas/download"] const isProtectedPath = protectedPaths.some((path) => request.nextUrl.pathname.startsWith(path)) if (isProtectedPath) { return await updateSession(request) } // Para otras rutas, continuar sin autenticación return } export const config = { matcher: [ /* * Match all request paths except for the ones starting with: * - _next/static (static files) * - _next/image (image optimization files) * - favicon.ico (favicon file) * Feel free to modify this pattern to include more paths. */ "/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)", ], } [V0_FILE]typescriptreact:file="app/globals.css" isEdit="true" isQuickEdit="true" isMerged="true" @tailwind base; @tailwind components; @tailwind utilities; @layer base { :root { --background: 0 0% 100%; --foreground: 0 0% 0%; --card: 0 0% 100%; --card-foreground: 0 0% 0%; --popover: 0 0% 100%; --popover-foreground: 0 0% 0%; --primary: 45 100% 51%; --primary-foreground: 0 0% 0%; --secondary: 0 0% 96%; --secondary-foreground: 0 0% 20%; --muted: 0 0% 96%; --muted-foreground: 0 0% 45%; --accent: 45 100% 51%; --accent-foreground: 0 0% 0%; --destructive: 0 84.2% 60.2%; --destructive-foreground: 0 0% 98%; --border: 0 0% 90%; --input: 0 0% 90%; --ring: 45 100% 51%; --radius: 0.75rem; /* Colores personalizados Agustin Esterman */ --brand-gold: 45 100% 51%; --brand-gold-dark: 38 92% 50%; --brand-black: 0 0% 11%; --brand-gray: 0 0% 17%; --brand-white: 0 0% 100%; } .dark { --background: 0 0% 11%; --foreground: 0 0% 98%; --card: 0 0% 11%; --card-foreground: 0 0% 98%; --popover: 0 0% 11%; --popover-foreground: 0 0% 98%; --primary: 45 100% 51%; --primary-foreground: 0 0% 0%; --secondary: 0 0% 17%; --secondary-foreground: 0 0% 98%; --muted: 0 0% 17%; --muted-foreground: 0 0% 65%; --accent: 45 100% 51%; --accent-foreground: 0 0% 0%; --destructive: 0 62.8% 30.6%; --destructive-foreground: 0 0% 98%; --border: 0 0% 20%; --input: 0 0% 20%; --ring: 45 100% 51%; } } @layer base { * { @apply border-border; } body { @apply bg-background text-foreground; } } /* Animaciones personalizadas */ @keyframes float { 0%, 100% { transform: translateY(0px); } 50% { transform: translateY(-10px); } } @keyframes glow { 0%, 100% { box-shadow: 0 0 20px rgba(255, 215, 0, 0.3); } 50% { box-shadow: 0 0 30px rgba(255, 215, 0, 0.6); } } .float-animation { animation: float 3s ease-in-out infinite; } .glow-animation { animation: glow 2s ease-in-out infinite; } /* Gradientes personalizados */ .gradient-gold { background: linear-gradient(135deg, #ffd700 0%, #ffa500 100%); } .gradient-black { background: linear-gradient(135deg, #1c1c1c 0%, #2c2c2c 100%); } .gradient-overlay { background: linear-gradient(135deg, rgba(28, 28, 28, 0.9) 0%, rgba(28, 28, 28, 0.7) 100%); } /* Efectos de texto */ .text-shadow-gold { text-shadow: 2px 2px 4px rgba(255, 215, 0, 0.3); } .text-shadow-black { text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5); } /* Efectos de hover profesionales */ .hover-lift { transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1); } .hover-lift:hover { transform: translateY(-8px); box-shadow: 0 20px 40px rgba(0, 0, 0, 0.1); } .hover-glow:hover { box-shadow: 0 0 30px rgba(255, 215, 0, 0.4); } /* Importar tipografías elegantes */ @import url("https://fonts.googleapis.com/css2?family=Playfair+Display:wght@400;500;600;700;800;900&family=Cinzel:wght@400;500;600;700;800;900&family=Cormorant+Garamond:wght@300;400;500;600;700&display=swap"); /* Tipografías personalizadas para el título */ .title-elegant { font-family: "Cinzel", serif; font-weight: 700; letter-spacing: 0.05em; } .title-sophisticated { font-family: "Playfair Display", serif; font-weight: 800; letter-spacing: 0.02em; } .subtitle-elegant { font-family: "Cormorant Garamond", serif; font-weight: 600; letter-spacing: 0.08em; } /* Efectos de texto mejorados */ .text-shadow-gold-strong { text-shadow: 3px 3px 6px rgba(255, 215, 0, 0.4), 0 0 20px rgba(255, 215, 0, 0.2); } .text-shadow-black-strong { text-shadow: 2px 2px 8px rgba(0, 0, 0, 0.8), 0 0 15px rgba(0, 0, 0, 0.3); } /* Logo sin fondo */ .logo-transparent { background: transparent !important; backdrop-filter: none !important; } /* Efecto de resplandor dorado para logo transparente */ .glow-gold-transparent { filter: drop-shadow(0 0 20px rgba(255, 215, 0, 0.6)) drop-shadow(0 0 40px rgba(255, 215, 0, 0.3)); } [V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { BookOpen, Download, ShoppingCart, BarChart3, TrendingUp, Users, Award, Target, Star, CheckCircle, ArrowRight, } from "lucide-react" import Link from "next/link" import Image from "next/image" export default function HomePage() { return (

{/* Hero Section Principal */}

{/* Background con múltiples capas */}

{/* Contenido Principal */}

{/* Logo con efecto flotante */}

{/* Título Principal */}

AGUSTIN

ESTERMAN

COACH

{/* Subtítulo */}

Análisis Deportivo de Elite • Entrenamiento Científico • Optimización del Rendimiento

Más de 15 años transformando atletas con metodología basada en datos y ciencia aplicada

{/* Botones de Acción */}

{/* Estadísticas Destacadas */}

{[ { number: "500+", label: "Atletas Entrenados", icon: Users }, { number: "15+", label: "Años Experiencia", icon: Award }, { number: "10K+", label: "Análisis Realizados", icon: TrendingUp }, { number: "95%", label: "Éxito Comprobado", icon: Star }, ].map((stat, index) => (

{stat.number}

{stat.label}

))}

{/* Scroll Indicator */}

{/* Sección Sobre Mí */}

Especialista en Análisis de Rendimiento

Mi enfoque combina la experiencia práctica con la metodología científica más avanzada. Cada análisis, cada programa, cada recomendación está respaldada por datos objetivos y años de experiencia transformando atletas de todos los niveles.

{[ { icon: BarChart3, title: "Análisis Basado en Datos", description: "Evaluación objetiva mediante tecnología avanzada y métricas validadas científicamente para decisiones precisas.", }, { icon: Target, title: "Entrenamiento Personalizado", description: "Programas adaptados a las necesidades específicas de cada atleta, deporte y objetivo de rendimiento.", }, { icon: TrendingUp, title: "Mejora Continua", description: "Monitoreo constante del progreso con ajustes basados en resultados objetivos y retroalimentación.", }, ].map((item, index) => (

{item.title}

{item.description}

))}

{/* Sección de Servicios */}

Servicios Profesionales

Herramientas y recursos diseñados para llevar tu entrenamiento al más alto nivel

{/* Blog */}

Blog Especializado Artículos sobre metodología, biomecánica y ciencias del deporte

Periodización avanzada
Análisis biomecánico
Casos de estudio reales

{/* Herramientas */}

Recursos Gratuitos Herramientas profesionales y calculadoras especializadas

Calculadoras de 1RM
Plantillas de periodización
Protocolos de evaluación

{/* Planes */}

Planes de Entrenamiento Programas completos con metodología científica

Fuerza máxima
Potencia explosiva
Acondicionamiento específico

{/* Dashboard */}

SLJ-Dashboard Pro Sistema avanzado de análisis de saltos y métricas

Análisis CMJ, SJ, DJ, RSI
Gráficos profesionales
Seguimiento histórico

{/* Sección de Testimonios */}

Lo que dicen los Profesionales

{[ { name: "Dr. Carlos Martínez", role: "Preparador Físico - Club Atlético", text: "El análisis de Agustin transformó completamente nuestro enfoque de entrenamiento. Los datos objetivos nos permitieron optimizar el rendimiento de cada jugador.", rating: 5, }, { name: "Prof. Ana López", role: "Entrenadora Nacional", text: "La metodología científica y la precisión en el análisis biomecánico son excepcionales. Herramientas indispensables para el alto rendimiento.", rating: 5, }, { name: "Lic. Miguel Torres", role: "Director Técnico", text: "Los reportes detallados y las recomendaciones personalizadas han sido clave para el desarrollo de nuestros atletas jóvenes.", rating: 5, }, ].map((testimonial, index) => (

{[...Array(testimonial.rating)].map((_, i) => ( ))}

"{testimonial.text}"

{testimonial.name .split(" ") .map((n) => n[0]) .join("")}

{testimonial.name}

{testimonial.role}

))}

{/* CTA Final */}

¿Listo para Optimizar tu Rendimiento?

Únete a cientos de atletas que ya han transformado su entrenamiento con análisis científico y metodología profesional

) } [V0_FILE]typescriptreact:file="components/app-sidebar.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Home, BookOpen, Download, ShoppingCart, BarChart3 } from "lucide-react" import Link from "next/link" import { usePathname } from "next/navigation" import Image from "next/image" import { Sidebar, SidebarContent, SidebarGroup, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarMenu, SidebarMenuButton, SidebarMenuItem, SidebarFooter, } from "@/components/ui/sidebar" const menuItems = [ { title: "Inicio", url: "/", icon: Home, }, { title: "Blog", url: "/blog", icon: BookOpen, }, { title: "Herramientas Gratis", url: "/herramientas", icon: Download, requiresAuth: true, }, { title: "Planes de Entrenamiento", url: "/planes", icon: ShoppingCart, }, { title: "SLJ-Dashboard", url: "/dashboard", icon: BarChart3, requiresAuth: true, }, ] export function AppSidebar() { const pathname = usePathname() return (

Agustin Esterman

Coach

Navegación Principal {menuItems.map((item) => ( {item.title} {item.requiresAuth && (

)} ))}

Análisis Deportivo Profesional

) } [V0_FILE]json:file="package.json" isMerged="true" { "name": "supabase-auth-template", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint" }, "dependencies": { "@ai-sdk/openai": "^0.0.66", "@radix-ui/react-accordion": "^1.2.1", "@radix-ui/react-alert-dialog": "^1.1.2", "@radix-ui/react-avatar": "^1.1.1", "@radix-ui/react-checkbox": "^1.1.2", "@radix-ui/react-collapsible": "^1.1.1", "@radix-ui/react-dialog": "^1.1.2", "@radix-ui/react-dropdown-menu": "^2.1.2", "@radix-ui/react-label": "^2.1.0", "@radix-ui/react-popover": "^1.1.2", "@radix-ui/react-progress": "^1.1.0", "@radix-ui/react-select": "^2.1.2", "@radix-ui/react-separator": "^1.1.0", "@radix-ui/react-slot": "^1.1.0", "@radix-ui/react-tabs": "^1.1.1", "@radix-ui/react-toast": "^1.2.2", "@radix-ui/react-tooltip": "^1.1.3", "@supabase/auth-helpers-nextjs": "^0.10.0", "@supabase/supabase-js": "^2.45.4", "ai": "^3.4.32", "class-variance-authority": "^0.7.0", "clsx": "^2.1.1", "lucide-react": "^0.454.0", "next": "15.0.3", "react": "^18.3.1", "react-dom": "^18.3.1", "react-dropzone": "^14.2.9", "recharts": "^2.13.3", "tailwind-merge": "^2.5.4", "tailwindcss-animate": "^1.0.7", "xlsx": "^0.18.5" }, "devDependencies": { "@types/node": "^20.17.6", "@types/react": "^18.3.12", "@types/react-dom": "^18.3.1", "eslint": "^8.57.1", "eslint-config-next": "15.0.3", "postcss": "^8.5.1", "tailwindcss": "^3.4.14", "typescript": "^5.6.3" } } [V0_FILE]typescriptreact:file="lib/file-processor.ts" isEdit="true" isQuickEdit="true" isMerged="true" import * as XLSX from "xlsx" export interface RawPlayerData { nombre: string posicion: string cmj: number sj: number dj: number rsi: number tc: number } export interface ProcessedPlayerData extends RawPlayerData { eur: number zScores: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } export interface TeamStats { mean: { cmj: number sj: number dj: number rsi: number tc: number eur: number } std: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } // Expandir significativamente el mapeo de columnas para ser más flexible const COLUMN_MAPPINGS = { nombre: [ // Español "nombre", "nombres", "jugador", "jugadores", "atleta", "atletas", "deportista", "deportistas", // Inglés "name", "names", "player", "players", "athlete", "athletes", "first name", "firstname", "full name", "fullname", "player name", "playername", // Variaciones comunes "nom", "nomb", "jug", "atl", "dep", ], posicion: [ // Español "posicion", "posición", "pos", "position", "puesto", "lugar", "demarcacion", "demarcación", "posic", "posic.", "posición de juego", "posicion de juego", // Inglés "position", "pos", "role", "field position", "playing position", // Abreviaciones "p", "ps", "pst", "dem", ], cmj: [ // Nombres completos "cmj", "counter movement jump", "countermovementjump", "counter-movement jump", "salto con contramovimiento", "salto contramovimiento", "salto contra movimiento", // Variaciones "cmj (cm)", "cmj(cm)", "cmj cm", "cmj_cm", "cmj-cm", "counter jump", "contra jump", "c.m.j", "c m j", // Con unidades "cmj altura", "cmj height", "altura cmj", "height cmj", ], sj: [ // Nombres completos "sj", "squat jump", "squatjump", "squat-jump", "salto en cuclillas", "salto cuclillas", "salto desde sentadilla", // Variaciones "sj (cm)", "sj(cm)", "sj cm", "sj_cm", "sj-cm", "s.j", "s j", "squat", "sentadilla jump", // Con unidades "sj altura", "sj height", "altura sj", "height sj", ], dj: [ // Nombres completos "dj", "drop jump", "dropjump", "drop-jump", "salto en caida", "salto caída", "salto desde caida", "salto desde caída", "salto reactivo", "reactive jump", // Variaciones "dj (cm)", "dj(cm)", "dj cm", "dj_cm", "dj-cm", "d.j", "d j", "drop", "caida", "caída", // Con unidades "dj altura", "dj height", "altura dj", "height dj", ], rsi: [ // Nombres completos "rsi", "reactive strength index", "reactivestrengthindex", "reactive-strength-index", "indice de fuerza reactiva", "índice de fuerza reactiva", "ifr", "indice fuerza reactiva", "índice fuerza reactiva", // Variaciones "r.s.i", "r s i", "reactive index", "strength index", "rsi index", "rsi índice", "reactive strength", // Abreviaciones "react str index", "react strength", "fuerza reactiva", ], tc: [ // Español "tc", "tiempo contacto", "tiempo de contacto", "t contacto", "t. contacto", "tiempo_contacto", "tiempo-contacto", "tcontacto", "t_contacto", "tiempo suelo", "tiempo en suelo", "contacto suelo", // Inglés "contact time", "contacttime", "contact-time", "ct", "c.t", "c t", "ground contact", "ground contact time", "ground time", "contact duration", "floor contact", "surface contact", // Con unidades "tc (s)", "tc(s)", "tc s", "tc_s", "tc-s", "tc seg", "tc segundos", "contact time (s)", "contact time(s)", "tiempo contacto (s)", // Variaciones "t.c", "t c", "tiemp cont", "cont time", ], } // Función mejorada para encontrar columnas con mayor flexibilidad function findColumnIndex(headers: string[], possibleNames: string[]): number { const normalizedHeaders = headers.map( (h) => h .toLowerCase() .trim() .replace(/[áàäâ]/g, "a") .replace(/[éèëê]/g, "e") .replace(/[íìïî]/g, "i") .replace(/[óòöô]/g, "o") .replace(/[úùüû]/g, "u") .replace(/[ñ]/g, "n") .replace(/[ç]/g, "c") .replace(/[^\w\s]/g, "") // Remover caracteres especiales .replace(/\s+/g, " "), // Normalizar espacios ) // Buscar coincidencia exacta primero for (const name of possibleNames) { const normalizedName = name .toLowerCase() .replace(/[áàäâ]/g, "a") .replace(/[éèëê]/g, "e") .replace(/[íìïî]/g, "i") .replace(/[óòöô]/g, "o") .replace(/[úùüû]/g, "u") .replace(/[ñ]/g, "n") .replace(/[ç]/g, "c") .replace(/[^\w\s]/g, "") .replace(/\s+/g, " ") const exactIndex = normalizedHeaders.findIndex((h) => h === normalizedName) if (exactIndex !== -1) return exactIndex } // Buscar coincidencia parcial (contiene) for (const name of possibleNames) { const normalizedName = name .toLowerCase() .replace(/[áàäâ]/g, "a") .replace(/[éèëê]/g, "e") .replace(/[íìïî]/g, "i") .replace(/[óòöô]/g, "o") .replace(/[úùüû]/g, "u") .replace(/[ñ]/g, "n") .replace(/[ç]/g, "c") .replace(/[^\w\s]/g, "") .replace(/\s+/g, " ") const containsIndex = normalizedHeaders.findIndex((h) => h.includes(normalizedName) || normalizedName.includes(h)) if (containsIndex !== -1) return containsIndex } // Buscar por palabras clave individuales for (const name of possibleNames) { const words = name.toLowerCase().split(/\s+/) for (const word of words) { if (word.length >= 2) { // Solo palabras de 2+ caracteres const wordIndex = normalizedHeaders.findIndex((h) => h.includes(word)) if (wordIndex !== -1) return wordIndex } } } return -1 } // Función mejorada para parsear valores numéricos con más flexibilidad function parseNumericValue(value: any): number { if (typeof value === "number") return value if (typeof value === "string") { // Remover espacios, unidades comunes y caracteres no numéricos const cleaned = value .trim() .replace(/cm/gi, "") .replace(/seg/gi, "") .replace(/s\b/gi, "") .replace(/metros/gi, "") .replace(/centimetros/gi, "") .replace(/segundos/gi, "") .replace(/[^\d.,\-+]/g, "") // Mantener solo dígitos, comas, puntos y signos .replace(/,/g, ".") // Reemplazar comas por puntos .trim() // Manejar casos especiales como "1,85" o "1.85" if (cleaned.includes(".")) { const parts = cleaned.split(".") if (parts.length === 2 && parts[1].length <= 3) { // Probablemente es un decimal válido const parsed = Number.parseFloat(cleaned) return isNaN(parsed) ? 0 : parsed } } const parsed = Number.parseFloat(cleaned) return isNaN(parsed) ? 0 : parsed } return 0 } // Función para detectar automáticamente el tipo de archivo y procesarlo export async function processFile(file: File): Promise { return new Promise((resolve, reject) => { const reader = new FileReader() reader.onload = (e) => { try { const data = e.target?.result let workbook: XLSX.WorkBook // Detectar tipo de archivo y procesarlo apropiadamente const fileName = file.name.toLowerCase() if (fileName.endsWith(".csv")) { workbook = XLSX.read(data, { type: "binary", raw: false, cellDates: true, dateNF: "yyyy-mm-dd", }) } else if (fileName.endsWith(".xlsx") || fileName.endsWith(".xls")) { workbook = XLSX.read(data, { type: "array", raw: false, cellDates: true, dateNF: "yyyy-mm-dd", }) } else { throw new Error("Formato de archivo no soportado. Use .xlsx, .xls o .csv") } const sheetName = workbook.SheetNames[0] const worksheet = workbook.Sheets[sheetName] // Convertir a JSON con opciones flexibles const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1, raw: false, defval: "", }) as any[][] if (jsonData.length < 2) { throw new Error("El archivo debe contener al menos una fila de encabezados y una fila de datos") } // Encontrar la fila de encabezados (puede no ser la primera) let headerRowIndex = 0 let headers: string[] = [] for (let i = 0; i < Math.min(5, jsonData.length); i++) { const row = jsonData[i] if (row && row.length > 0) { const potentialHeaders = row.map((h) => String(h || "").trim()).filter((h) => h.length > 0) // Verificar si esta fila parece contener encabezados const hasTextHeaders = potentialHeaders.some((h) => isNaN(Number(h)) && h.length > 1) if (hasTextHeaders && potentialHeaders.length >= 5) { headerRowIndex = i headers = potentialHeaders break } } } if (headers.length === 0) { throw new Error( "No se pudieron identificar los encabezados de columna. Asegúrate de que la primera fila contenga los nombres de las columnas.", ) } // Filtrar filas de datos (después de los encabezados) const dataRows = jsonData.slice(headerRowIndex + 1).filter((row) => { if (!row || row.length === 0) return false // Verificar que la fila tenga al menos algunos datos válidos const nonEmptyValues = row.filter( (cell) => cell !== null && cell !== undefined && cell !== "" && String(cell).trim() !== "", ) return nonEmptyValues.length >= 3 // Al menos 3 valores no vacíos }) if (dataRows.length === 0) { throw new Error("No se encontraron filas de datos válidas después de los encabezados") } // Encontrar índices de columnas con el mapeo flexible const columnIndices = { nombre: findColumnIndex(headers, COLUMN_MAPPINGS.nombre), posicion: findColumnIndex(headers, COLUMN_MAPPINGS.posicion), cmj: findColumnIndex(headers, COLUMN_MAPPINGS.cmj), sj: findColumnIndex(headers, COLUMN_MAPPINGS.sj), dj: findColumnIndex(headers, COLUMN_MAPPINGS.dj), rsi: findColumnIndex(headers, COLUMN_MAPPINGS.rsi), tc: findColumnIndex(headers, COLUMN_MAPPINGS.tc), } // Mostrar qué columnas se encontraron para debugging console.log("Encabezados encontrados:", headers) console.log( "Mapeo de columnas:", Object.entries(columnIndices).map( ([key, index]) => `${key}: ${index !== -1 ? headers[index] : "NO ENCONTRADA"}`, ), ) // ¿Qué columnas son obligatorias? const requiredCols = ["nombre", "cmj", "sj", "dj", "rsi", "tc"] as const const missingColumns = requiredCols.filter((key) => columnIndices[key] === -1) if (missingColumns.length > 0) { const availableColumns = headers.join(", ") const suggestions = missingColumns .map((col) => { const names = COLUMN_MAPPINGS[col as keyof typeof COLUMN_MAPPINGS].slice(0, 3) return `${col}: ${names.join(", ")}` }) .join("\n") throw new Error(`No se encontraron las siguientes columnas requeridas: ${missingColumns.join(", ")} Columnas disponibles en tu archivo: ${availableColumns} Nombres sugeridos para las columnas faltantes: ${suggestions} Tip: Las columnas pueden tener nombres en español o inglés, con o sin acentos, y pueden incluir unidades como (cm) o (s).`) } // Procesar datos con validación mejorada const players: RawPlayerData[] = [] const errors: string[] = [] dataRows.forEach((row, index) => { try { const rowNumber = headerRowIndex + index + 2 // +2 porque empezamos desde 0 y saltamos header const nombre = String(row[columnIndices.nombre] || "").trim() const posicion = columnIndices.posicion !== -1 ? String(row[columnIndices.posicion] || "").trim() || "Sin posición" : "Sin posición" const cmj = parseNumericValue(row[columnIndices.cmj]) const sj = parseNumericValue(row[columnIndices.sj]) const dj = parseNumericValue(row[columnIndices.dj]) const rsi = parseNumericValue(row[columnIndices.rsi]) const tc = parseNumericValue(row[columnIndices.tc]) // Validaciones con mensajes específicos if (!nombre) { errors.push(`Fila ${rowNumber}: El nombre del jugador es requerido`) return } // Validaciones de rangos razonables if (cmj <= 0 || cmj > 100) { errors.push(`Fila ${rowNumber}: CMJ debe estar entre 0 y 100 cm (valor actual: ${cmj})`) return } if (sj <= 0 || sj > 100) { errors.push(`Fila ${rowNumber}: SJ debe estar entre 0 y 100 cm (valor actual: ${sj})`) return } if (dj <= 0 || dj > 100) { errors.push(`Fila ${rowNumber}: DJ debe estar entre 0 y 100 cm (valor actual: ${dj})`) return } if (rsi <= 0 || rsi > 10) { errors.push(`Fila ${rowNumber}: RSI debe estar entre 0 y 10 (valor actual: ${rsi})`) return } if (tc <= 0 || tc > 2) { errors.push(`Fila ${rowNumber}: TC debe estar entre 0 y 2 segundos (valor actual: ${tc})`) return } players.push({ nombre, posicion, cmj, sj, dj, rsi, tc, }) } catch (error) { errors.push(`Fila ${headerRowIndex + index + 2}: Error procesando datos - ${error}`) } }) // Si hay errores, mostrar los primeros 5 if (errors.length > 0) { const errorMessage = errors.slice(0, 5).join("\n") const additionalErrors = errors.length > 5 ? `\n... y ${errors.length - 5} errores más` : "" throw new Error(`Se encontraron errores en los datos:\n\n${errorMessage}${additionalErrors}`) } if (players.length === 0) { throw new Error("No se encontraron datos válidos en el archivo después de aplicar las validaciones") } console.log(`Procesados exitosamente ${players.length} jugadores`) resolve(players) } catch (error) { console.error("Error procesando archivo:", error) reject(error) } } reader.onerror = () => reject(new Error("Error al leer el archivo")) // Leer archivo según su tipo if (file.name.toLowerCase().endsWith(".csv")) { reader.readAsBinaryString(file) } else { reader.readAsArrayBuffer(file) } }) } export function calculateEUR(cmj: number, sj: number): number { return ((cmj - sj) / sj) * 100 } export function calculateZScore(value: number, mean: number, std: number): number { return std === 0 ? 0 : (value - mean) / std } export function processTeamData(rawPlayers: RawPlayerData[]): { players: ProcessedPlayerData[] teamStats: TeamStats } { // Calcular EUR para cada jugador const playersWithEUR = rawPlayers.map((player) => ({ ...player, eur: calculateEUR(player.cmj, player.sj), })) // Calcular estadísticas del equipo const metrics = ["cmj", "sj", "dj", "rsi", "tc", "eur"] as const const stats: TeamStats = { mean: {} as any, std: {} as any, } metrics.forEach((metric) => { const values = playersWithEUR.map((p) => p[metric] as number) const mean = values.reduce((a, b) => a + b, 0) / values.length const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / values.length const std = Math.sqrt(variance) stats.mean[metric] = mean stats.std[metric] = std }) // Calcular Z-scores para cada jugador const processedPlayers: ProcessedPlayerData[] = playersWithEUR.map((player) => ({ ...player, zScores: { cmj: calculateZScore(player.cmj, stats.mean.cmj, stats.std.cmj), sj: calculateZScore(player.sj, stats.mean.sj, stats.std.sj), dj: calculateZScore(player.dj, stats.mean.dj, stats.std.dj), rsi: calculateZScore(player.rsi, stats.mean.rsi, stats.std.rsi), tc: calculateZScore(player.tc, stats.mean.tc, stats.std.tc), eur: calculateZScore(player.eur, stats.mean.eur, stats.std.eur), }, })) return { players: processedPlayers, teamStats: stats, } } [V0_FILE]sql:file="scripts/20250619-add-unique-players-team-name.sql" isMerged="true" -- Añade una restricción UNIQUE para permitir upsert por (team_id, name) ALTER TABLE players ADD CONSTRAINT players_team_id_name_key UNIQUE (team_id, name); [V0_FILE]typescriptreact:file="components/area-charts.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Area, AreaChart, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, Legend } from "recharts" interface PlayerData { nombre: string posicion: string cmj: number sj: number dj: number rsi: number tc: number eur?: number zScores?: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface JumpMetricsChartProps { players: PlayerData[] } interface DJvsRSIChartProps { players: PlayerData[] } export function JumpMetricsChart({ players }: JumpMetricsChartProps) { // Preparar datos para el gráfico CMJ, SJ, DJ const chartData = players .sort((a, b) => a.nombre.localeCompare(b.nombre)) .map((player, index) => ({ jugador: player.nombre.split(" ")[0], // Solo primer nombre para mejor visualización posicion: player.posicion, CMJ: Number(player.cmj) || 0, SJ: Number(player.sj) || 0, DJ: Number(player.dj) || 0, index: index, })) const CustomTooltip = ({ active, payload, label }: any) => { if (active && payload && payload.length) { const data = payload[0].payload return (

{`${label} (${data.posicion})`}

{payload.map((entry: any, index: number) => (

{`${entry.dataKey}: ${entry.value.toFixed(1)} cm`}

))}

) } return null } return (

} />

) } export function DJvsRSIChart({ players }: DJvsRSIChartProps) { // Preparar datos para el gráfico DJ vs RSI const chartData = players .sort((a, b) => a.nombre.localeCompare(b.nombre)) .map((player, index) => ({ jugador: player.nombre.split(" ")[0], // Solo primer nombre posicion: player.posicion, DJ: Number(player.dj) || 0, RSI: (Number(player.rsi) || 0) * 10, // Multiplicar por 10 para mejor visualización RSI_original: Number(player.rsi) || 0, // Mantener valor original para tooltip index: index, })) const CustomTooltip = ({ active, payload, label }: any) => { if (active && payload && payload.length) { const data = payload[0].payload return (

{`${label} (${data.posicion})`}

{`DJ: ${data.DJ.toFixed(1)} cm`}

{`RSI: ${data.RSI_original.toFixed(2)}`}

) } return null } return (

} /> (value === "RSI" ? "RSI (x10 para visualización)" : value)} />

) } [V0_FILE]typescriptreact:file="components/individual-charts.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Bar, BarChart, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, Legend, Area, AreaChart, } from "recharts" interface PlayerData { nombre: string posicion: string cmj: number sj: number dj: number rsi: number tc: number eur?: number zScores?: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface HistoricalData { fecha: string cmj: number sj: number dj: number rsi: number tc: number } interface IndividualChartsProps { player: PlayerData historicalData?: HistoricalData[] } // Datos históricos simulados para demostración const generateHistoricalData = (player: PlayerData): HistoricalData[] => { const baseData = { cmj: player.cmj, sj: player.sj, dj: player.dj, rsi: player.rsi, tc: player.tc, } // Generar 8 puntos de datos históricos con variaciones realistas const dates = ["Ene 2024", "Feb 2024", "Mar 2024", "Abr 2024", "May 2024", "Jun 2024", "Jul 2024", "Ago 2024"] return dates.map((fecha, index) => { const variation = (Math.random() - 0.5) * 0.1 // ±5% de variación const trend = index * 0.02 // Tendencia de mejora gradual return { fecha, cmj: Number((baseData.cmj * (1 + variation + trend)).toFixed(1)), sj: Number((baseData.sj * (1 + variation + trend)).toFixed(1)), dj: Number((baseData.dj * (1 + variation + trend)).toFixed(1)), rsi: Number((baseData.rsi * (1 + variation + trend)).toFixed(2)), tc: Number((baseData.tc * (1 - variation - trend * 0.5)).toFixed(3)), // TC mejora cuando disminuye } }) } export function IndividualTrendsBarChart({ player, historicalData }: IndividualChartsProps) { const data = historicalData || generateHistoricalData(player) const CustomTooltip = ({ active, payload, label }: any) => { if (active && payload && payload.length) { return (

{label}

{payload.map((entry: any, index: number) => (

{`${entry.dataKey.toUpperCase()}: ${entry.value} cm`}

))}

) } return null } return (

} />

) } export function IndividualAreaChart({ player, historicalData }: IndividualChartsProps) { const data = historicalData || generateHistoricalData(player) const CustomTooltip = ({ active, payload, label }: any) => { if (active && payload && payload.length) { return (

{label}

{payload.map((entry: any, index: number) => (

{`${entry.dataKey.toUpperCase()}: ${entry.value} cm`}

))}

) } return null } return (

} />

) } export function IndividualDJvsRSIChart({ player, historicalData }: IndividualChartsProps) { const data = (historicalData || generateHistoricalData(player)).map((item) => ({ ...item, RSI_scaled: item.rsi * 10, // Escalar para visualización })) const CustomTooltip = ({ active, payload, label }: any) => { if (active && payload && payload.length) { const originalRSI = payload.find((p: any) => p.dataKey === "RSI_scaled") return (

{label}

{`DJ: ${payload.find((p: any) => p.dataKey === "dj")?.value} cm`}

{`RSI: ${(originalRSI?.value / 10).toFixed(2)}`}

) } return null } return (

} /> (value === "RSI_scaled" ? "RSI (x10 para visualización)" : value)} />

) } export function ProgressSummary({ player, historicalData }: IndividualChartsProps) { const data = historicalData || generateHistoricalData(player) const firstRecord = data[0] const lastRecord = data[data.length - 1] const calculateProgress = (initial: number, final: number) => { const change = final - initial const percentage = (change / initial) * 100 return { change: change.toFixed(1), percentage: percentage.toFixed(1) } } const cmjProgress = calculateProgress(firstRecord.cmj, lastRecord.cmj) const sjProgress = calculateProgress(firstRecord.sj, lastRecord.sj) const djProgress = calculateProgress(firstRecord.dj, lastRecord.dj) const rsiProgress = calculateProgress(firstRecord.rsi, lastRecord.rsi) const getProgressColor = (percentage: string) => { const num = Number.parseFloat(percentage) if (num > 2) return "text-green-600" if (num > 0) return "text-blue-600" if (num > -2) return "text-orange-600" return "text-red-600" } const getProgressIcon = (percentage: string) => { const num = Number.parseFloat(percentage) return num > 0 ? "↗" : "↘" } return (

CMJ

{getProgressIcon(cmjProgress.percentage)} {cmjProgress.change} cm

{cmjProgress.percentage}%

SJ

{getProgressIcon(sjProgress.percentage)} {sjProgress.change} cm

{sjProgress.percentage}%

DJ

{getProgressIcon(djProgress.percentage)} {djProgress.change} cm

{djProgress.percentage}%

RSI

{getProgressIcon(rsiProgress.percentage)} {rsiProgress.change}

{rsiProgress.percentage}%

) } [V0_FILE]typescriptreact:file="components/radar-chart.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Radar, RadarChart as RechartsRadarChart, PolarGrid, PolarAngleAxis, PolarRadiusAxis, ResponsiveContainer, Legend, } from "recharts" interface PlayerData { nombre: string posicion: string cmj: number sj: number dj: number rsi: number tc: number eur?: number zScores?: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface TeamStats { mean: { cmj: number sj: number dj: number rsi: number tc: number eur: number } std: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface RadarChartProps { playerData: PlayerData teamStats: TeamStats } export function RadarChart({ playerData, teamStats }: RadarChartProps) { if (!playerData.zScores) return null const data = [ { metric: "CMJ", jugador: Number(playerData.zScores.cmj) || 0, equipo: 0, }, { metric: "SJ", jugador: Number(playerData.zScores.sj) || 0, equipo: 0, }, { metric: "DJ", jugador: Number(playerData.zScores.dj) || 0, equipo: 0, }, { metric: "RSI", jugador: Number(playerData.zScores.rsi) || 0, equipo: 0, }, { metric: "TC", jugador: -(Number(playerData.zScores.tc) || 0), // Invertido porque menor TC es mejor equipo: 0, }, { metric: "EUR", jugador: Number(playerData.zScores.eur) || 0, equipo: 0, }, ] return (

) } [V0_FILE]typescriptreact:file="components/player-analysis.tsx" isEdit="true" isQuickEdit="true" isMerged="true" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Progress } from "@/components/ui/progress" import { IndividualTrendsBarChart, IndividualAreaChart, IndividualDJvsRSIChart, ProgressSummary, } from "@/components/individual-charts" interface PlayerData { nombre: string posicion: string cmj: number sj: number dj: number rsi: number tc: number eur?: number zScores?: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface TeamStats { mean: { cmj: number sj: number dj: number rsi: number tc: number eur: number } std: { cmj: number sj: number dj: number rsi: number tc: number eur: number } } interface PlayerAnalysisProps { player: PlayerData teamStats: TeamStats } export function PlayerAnalysis({ player, teamStats }: PlayerAnalysisProps) { const getZScoreColor = (zScore: number) => { if (zScore > 1) return "text-green-600" if (zScore > 0) return "text-blue-600" if (zScore > -1) return "text-orange-600" return "text-red-600" } const getZScoreBadge = (zScore: number) => { if (zScore > 1) return "Excelente" if (zScore > 0) return "Bueno" if (zScore > -1) return "Promedio" return "Necesita Mejora" } const getZScoreBadgeVariant = (zScore: number) => { if (zScore > 1) return "default" if (zScore > 0) return "secondary" if (zScore > -1) return "outline" return "destructive" } return (

{/* Player Info */} {player.nombre} {player.posicion} Análisis individual detallado

{player.cmj}

CMJ (cm)

{player.sj}

SJ (cm)

{player.rsi.toFixed(2)}

RSI

{player.eur?.toFixed(1)}%

EUR

{/* Z-Scores Analysis */} Análisis Z-Score Comparación con el promedio del equipo

{player.zScores && Object.entries(player.zScores).map(([metric, zScore]) => (

{metric.toUpperCase()}

{zScore > 0 ? "+" : ""} {zScore.toFixed(2)} {getZScoreBadge(zScore)}

-3σ Promedio +3σ

))}

{/* Recommendations */} Recomendaciones de Entrenamiento Sugerencias basadas en el análisis de datos

{player.zScores && ( <> {/* Fortalezas */}

Fortalezas

{Object.entries(player.zScores) .filter(([_, zScore]) => zScore > 0.5) .map(([metric, zScore]) => (

{metric.toUpperCase()} {metric === "cmj" && "Excelente capacidad de salto con contramovimiento"} {metric === "sj" && "Gran fuerza explosiva concéntrica"} {metric === "dj" && "Buena capacidad de salto reactivo"} {metric === "rsi" && "Excelente índice de fuerza reactiva"} {metric === "eur" && "Óptimo aprovechamiento del ciclo estiramiento-acortamiento"} {metric === "tc" && "Tiempo de contacto eficiente"}

))}

{/* Áreas de Mejora */}

Áreas de Mejora

{Object.entries(player.zScores) .filter(([_, zScore]) => zScore < -0.5) .map(([metric, zScore]) => (

{metric.toUpperCase()} {metric === "cmj" && "Trabajar saltos con contramovimiento"} {metric === "sj" && "Desarrollar fuerza explosiva concéntrica"} {metric === "dj" && "Mejorar capacidad de salto reactivo"} {metric === "rsi" && "Entrenar fuerza reactiva"} {metric === "eur" && "Optimizar técnica de salto"} {metric === "tc" && "Reducir tiempo de contacto"}

))}

)}

{/* Análisis Histórico */} Análisis de Tendencias Históricas Evolución del rendimiento a lo largo del tiempo {/* Resumen de Progreso */}

Progreso desde la Primera Evaluación

{/* Gráficos de Tendencias */}

{/* Gráfico de Barras de Tendencias */}

Tendencias por Período (SJ, CMJ, DJ)

{/* Gráficos de Área */}

Evolución de Saltos Verticales

DJ vs RSI - Evolución

{/* Insights de Tendencias */}

Insights de Tendencias

Patrón de Mejora: Los datos muestran una tendencia general de mejora en las métricas de salto vertical.

Consistencia: La variabilidad en los resultados indica la estabilidad del rendimiento del atleta.

) } [V0_FILE]sql:file="scripts/create-user-teams-system.sql" -- Crear tabla de perfiles de usuario (extiende auth.users) CREATE TABLE IF NOT EXISTS user_profiles ( id UUID REFERENCES auth.users(id) ON DELETE CASCADE PRIMARY KEY, email VARCHAR(255), full_name VARCHAR(255), default_team_id UUID, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Modificar tabla teams para incluir owner ALTER TABLE teams ADD COLUMN IF NOT EXISTS owner_id UUID REFERENCES auth.users(id) ON DELETE CASCADE, ADD COLUMN IF NOT EXISTS is_default BOOLEAN DEFAULT FALSE; -- Crear índices para mejor rendimiento CREATE INDEX IF NOT EXISTS idx_teams_owner_id ON teams(owner_id); CREATE INDEX IF NOT EXISTS idx_user_profiles_default_team ON user_profiles(default_team_id); -- Crear tabla de historial de evaluaciones CREATE TABLE IF NOT EXISTS evaluation_sessions ( id UUID DEFAULT gen_random_uuid() PRIMARY KEY, team_id UUID REFERENCES teams(id) ON DELETE CASCADE, user_id UUID REFERENCES auth.users(id) ON DELETE CASCADE, session_name VARCHAR(255), evaluation_date DATE DEFAULT CURRENT_DATE, notes TEXT, file_name VARCHAR(255), total_players INTEGER DEFAULT 0, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Modificar jump_analyses para incluir session_id ALTER TABLE jump_analyses ADD COLUMN IF NOT EXISTS session_id UUID REFERENCES evaluation_sessions(id) ON DELETE CASCADE; -- Crear índices adicionales CREATE INDEX IF NOT EXISTS idx_evaluation_sessions_team_id ON evaluation_sessions(team_id); CREATE INDEX IF NOT EXISTS idx_evaluation_sessions_user_id ON evaluation_sessions(user_id); CREATE INDEX IF NOT EXISTS idx_jump_analyses_session_id ON jump_analyses(session_id); -- Función para crear perfil de usuario automáticamente CREATE OR REPLACE FUNCTION create_user_profile() RETURNS TRIGGER AS $$ BEGIN INSERT INTO user_profiles (id, email, full_name) VALUES (NEW.id, NEW.email, NEW.raw_user_meta_data->>'full_name'); RETURN NEW; END; $$ LANGUAGE plpgsql; -- Trigger para crear perfil automáticamente DROP TRIGGER IF EXISTS on_auth_user_created ON auth.users; CREATE TRIGGER on_auth_user_created AFTER INSERT ON auth.users FOR EACH ROW EXECUTE FUNCTION create_user_profile(); -- Función para establecer equipo por defecto CREATE OR REPLACE FUNCTION set_default_team(user_id UUID, team_id UUID) RETURNS VOID AS $$ BEGIN -- Marcar todos los equipos del usuario como no default UPDATE teams SET is_default = FALSE WHERE owner_id = user_id; -- Marcar el equipo seleccionado como default UPDATE teams SET is_default = TRUE WHERE id = team_id AND owner_id = user_id; -- Actualizar el perfil del usuario UPDATE user_profiles SET default_team_id = team_id WHERE id = user_id; END; $$ LANGUAGE plpgsql; -- RLS (Row Level Security) para teams ALTER TABLE teams ENABLE ROW LEVEL SECURITY; CREATE POLICY "Users can view their own teams" ON teams FOR SELECT USING (auth.uid() = owner_id); CREATE POLICY "Users can insert their own teams" ON teams FOR INSERT WITH CHECK (auth.uid() = owner_id); CREATE POLICY "Users can update their own teams" ON teams FOR UPDATE USING (auth.uid() = owner_id); CREATE POLICY "Users can delete their own teams" ON teams FOR DELETE USING (auth.uid() = owner_id); -- RLS para players ALTER TABLE players ENABLE ROW LEVEL SECURITY; CREATE POLICY "Users can view players from their teams" ON players FOR SELECT USING ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = players.team_id AND teams.owner_id = auth.uid() ) ); CREATE POLICY "Users can insert players to their teams" ON players FOR INSERT WITH CHECK ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = players.team_id AND teams.owner_id = auth.uid() ) ); CREATE POLICY "Users can update players from their teams" ON players FOR UPDATE USING ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = players.team_id AND teams.owner_id = auth.uid() ) ); CREATE POLICY "Users can delete players from their teams" ON players FOR DELETE USING ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = players.team_id AND teams.owner_id = auth.uid() ) ); -- RLS para jump_analyses ALTER TABLE jump_analyses ENABLE ROW LEVEL SECURITY; CREATE POLICY "Users can view analyses from their teams" ON jump_analyses FOR SELECT USING ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = jump_analyses.team_id AND teams.owner_id = auth.uid() ) ); CREATE POLICY "Users can insert analyses to their teams" ON jump_analyses FOR INSERT WITH CHECK ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = jump_analyses.team_id AND teams.owner_id = auth.uid() ) ); CREATE POLICY "Users can update analyses from their teams" ON jump_analyses FOR UPDATE USING ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = jump_analyses.team_id AND teams.owner_id = auth.uid() ) ); CREATE POLICY "Users can delete analyses from their teams" ON jump_analyses FOR DELETE USING ( EXISTS ( SELECT 1 FROM teams WHERE teams.id = jump_analyses.team_id AND teams.owner_id = auth.uid() ) ); -- RLS para evaluation_sessions ALTER TABLE evaluation_sessions ENABLE ROW LEVEL SECURITY; CREATE POLICY "Users can view their own evaluation sessions" ON evaluation_sessions FOR SELECT USING (auth.uid() = user_id); CREATE POLICY "Users can insert their own evaluation sessions" ON evaluation_sessions FOR INSERT WITH CHECK (auth.uid() = user_id); CREATE POLICY "Users can update their own evaluation sessions" ON evaluation_sessions FOR UPDATE USING (auth.uid() = user_id); CREATE POLICY "Users can delete their own evaluation sessions" ON evaluation_sessions FOR DELETE USING (auth.uid() = user_id); -- RLS para user_profiles ALTER TABLE user_profiles ENABLE ROW LEVEL SECURITY; CREATE POLICY "Users can view their own profile" ON user_profiles FOR SELECT USING (auth.uid() = id); CREATE POLICY "Users can update their own profile" ON user_profiles FOR UPDATE USING (auth.uid() = id); [V0_FILE]typescriptreact:file="lib/supabase-helpers.ts" isEdit="true" "use server" import { createClient } from "@/lib/supabase/server" import type { RawPlayerData } from "./file-processor" export interface Team { id: string name: string sport?: string season?: string description?: string owner_id: string is_default: boolean created_at: string } export interface Player { id: string team_id: string name: string position?: string jersey_number?: number age?: number height?: number weight?: number } export interface JumpAnalysis { id: string player_id: string team_id: string session_id?: string test_date: string cmj: number sj: number dj: number rsi: number tc: number eur: number notes?: string } export interface EvaluationSession { id: string team_id: string user_id: string session_name: string evaluation_date: string notes?: string file_name?: string total_players: number created_at: string } export interface UserProfile { id: string email?: string full_name?: string default_team_id?: string created_at: string } // Obtener el usuario actual export async function getCurrentUser() { const supabase = createClient() const { data: { user }, error, } = await supabase.auth.getUser() if (error || !user) { throw new Error("Usuario no autenticado") } return user } // Obtener perfil del usuario export async function getUserProfile(userId?: string) { const supabase = createClient() const user = userId ? { id: userId } : await getCurrentUser() const { data, error } = await supabase.from("user_profiles").select("*").eq("id", user.id).single() if (error && error.code !== "PGRST116") { // PGRST116 = no rows returned throw new Error(`Error fetching user profile: ${error.message}`) } return data as UserProfile | null } // Obtener equipo por defecto del usuario export async function getUserDefaultTeam() { const supabase = createClient() const user = await getCurrentUser() const { data, error } = await supabase .from("teams") .select("*") .eq("owner_id", user.id) .eq("is_default", true) .single() if (error && error.code !== "PGRST116") { throw new Error(`Error fetching default team: ${error.message}`) } return data as Team | null } // Obtener todos los equipos del usuario export async function getUserTeams() { const supabase = createClient() const user = await getCurrentUser() const { data, error } = await supabase .from("teams") .select("*") .eq("owner_id", user.id) .order("is_default", { ascending: false }) .order("created_at", { ascending: false }) if (error) { throw new Error(`Error fetching teams: ${error.message}`) } return data as Team[] } // Crear o actualizar equipo con datos de jugadores export async function savePlayersData( playersData: RawPlayerData[], teamName: string, fileName?: string, teamId?: string, ) { const supabase = createClient() const user = await getCurrentUser() try { let team: Team if (teamId) { // Actualizar equipo existente const { data: existingTeam, error: teamError } = await supabase .from("teams") .select("*") .eq("id", teamId) .eq("owner_id", user.id) .single() if (teamError) { throw new Error(`Error fetching team: ${teamError.message}`) } team = existingTeam } else { // Crear nuevo equipo const { data: newTeam, error: teamError } = await supabase .from("teams") .insert([ { name: teamName, sport: "Fútbol", season: new Date().getFullYear().toString(), description: `Equipo creado desde dashboard - ${new Date().toLocaleDateString()}`, owner_id: user.id, is_default: true, // Primer equipo es por defecto }, ]) .select() .single() if (teamError) { throw new Error(`Error creating team: ${teamError.message}`) } team = newTeam // Establecer como equipo por defecto si es el primero const { error: defaultError } = await supabase.rpc("set_default_team", { user_id: user.id, team_id: team.id, }) if (defaultError) { console.warn("Warning setting default team:", defaultError.message) } } // Crear sesión de evaluación const { data: session, error: sessionError } = await supabase .from("evaluation_sessions") .insert([ { team_id: team.id, user_id: user.id, session_name: `Evaluación ${new Date().toLocaleDateString()}`, evaluation_date: new Date().toISOString().split("T")[0], file_name: fileName, total_players: playersData.length, notes: `Datos cargados desde archivo ${fileName || "sin nombre"}`, }, ]) .select() .single() if (sessionError) { throw new Error(`Error creating evaluation session: ${sessionError.message}`) } // Procesar jugadores (crear o actualizar) const playersToUpsert = playersData.map((player) => ({ team_id: team.id, name: player.nombre, position: player.posicion, })) const { data: players, error: playersError } = await supabase .from("players") .upsert(playersToUpsert, { onConflict: "team_id,name", ignoreDuplicates: false, }) .select() if (playersError) { throw new Error(`Error saving players: ${playersError.message}`) } // Crear análisis de saltos const jumpAnalyses = playersData.map((playerData, index) => ({ player_id: players[index].id, team_id: team.id, session_id: session.id, test_date: new Date().toISOString().split("T")[0], cmj: playerData.cmj, sj: playerData.sj, dj: playerData.dj, rsi: playerData.rsi, tc: playerData.tc, notes: `Evaluación de ${session.session_name}`, })) const { data: analyses, error: analysesError } = await supabase.from("jump_analyses").insert(jumpAnalyses).select() if (analysesError) { throw new Error(`Error saving jump analyses: ${analysesError.message}`) } return { team, players, analyses, session, } } catch (error) { console.error("Error in savePlayersData:", error) throw error } } // Obtener datos del equipo con análisis más recientes export async function getTeamLatestData(teamId?: string) { const supabase = createClient() const user = await getCurrentUser() let finalTeamId = teamId if (!finalTeamId) { // Obtener equipo por defecto const defaultTeam = await getUserDefaultTeam() if (!defaultTeam) { return null } finalTeamId = defaultTeam.id } // Obtener datos del equipo con jugadores y sus análisis más recientes const { data, error } = await supabase .from("teams") .select(` *, players ( *, jump_analyses ( *, evaluation_sessions ( session_name, evaluation_date ) ) ) `) .eq("id", finalTeamId) .eq("owner_id", user.id) .single() if (error) { throw new Error(`Error fetching team data: ${error.message}`) } return data } // Obtener análisis más recientes por jugador export async function getLatestAnalysesByTeam(teamId: string) { const supabase = createClient() const user = await getCurrentUser() const { data, error } = await supabase .from("jump_analyses") .select(` *, players ( name, position ), evaluation_sessions ( session_name, evaluation_date ) `) .eq("team_id", teamId) .order("test_date", { ascending: false }) if (error) { throw new Error(`Error fetching analyses: ${error.message}`) } // Agrupar por jugador y tomar el análisis más reciente const latestByPlayer = data.reduce( (acc, analysis) => { const playerId = analysis.player_id if (!acc[playerId] || new Date(analysis.test_date) > new Date(acc[playerId].test_date)) { acc[playerId] = analysis } return acc }, {} as Record, ) return Object.values(latestByPlayer) } // Obtener historial de evaluaciones export async function getEvaluationHistory(teamId: string) { const supabase = createClient() const user = await getCurrentUser() const { data, error } = await supabase .from("evaluation_sessions") .select("*") .eq("team_id", teamId) .eq("user_id", user.id) .order("evaluation_date", { ascending: false }) if (error) { throw new Error(`Error fetching evaluation history: ${error.message}`) } return data as EvaluationSession[] } // Establecer equipo por defecto export async function setDefaultTeam(teamId: string) { const supabase = createClient() const user = await getCurrentUser() const { error } = await supabase.rpc("set_default_team", { user_id: user.id, team_id: teamId, }) if (error) { throw new Error(`Error setting default team: ${error.message}`) } } // Crear nuevo equipo export async function createTeam(teamData: { name: string sport?: string season?: string description?: string }) { const supabase = createClient() const user = await getCurrentUser() const { data, error } = await supabase .from("teams") .insert([ { ...teamData, owner_id: user.id, is_default: false, }, ]) .select() .single() if (error) { throw new Error(`Error creating team: ${error.message}`) } return data as Team } // Eliminar equipo export async function deleteTeam(teamId: string) { const supabase = createClient() const user = await getCurrentUser() const { error } = await supabase.from("teams").delete().eq("id", teamId).eq("owner_id", user.id) if (error) { throw new Error(`Error deleting team: ${error.message}`) } } [V0_FILE]typescriptreact:file="components/team-selector.tsx" "use client" import { useState, useEffect } from "react" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Badge } from "@/components/ui/badge" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger, } from "@/components/ui/dialog" import { Plus, Users, Calendar, Star } from "lucide-react" import { getUserTeams, setDefaultTeam, createTeam, type Team } from "@/lib/supabase-helpers" interface TeamSelectorProps { onTeamSelected: (team: Team | null) => void selectedTeam: Team | null } export function TeamSelector({ onTeamSelected, selectedTeam }: TeamSelectorProps) { const [teams, setTeams] = useState([]) const [loading, setLoading] = useState(true) const [isCreateDialogOpen, setIsCreateDialogOpen] = useState(false) const [newTeamName, setNewTeamName] = useState("") const [newTeamSport, setNewTeamSport] = useState("Fútbol") useEffect(() => { loadTeams() }, []) const loadTeams = async () => { try { setLoading(true) const userTeams = await getUserTeams() setTeams(userTeams) // Si no hay equipo seleccionado, cargar el por defecto if (!selectedTeam && userTeams.length > 0) { const defaultTeam = userTeams.find((t) => t.is_default) || userTeams[0] onTeamSelected(defaultTeam) } } catch (error) { console.error("Error loading teams:", error) } finally { setLoading(false) } } const handleTeamChange = async (teamId: string) => { const team = teams.find((t) => t.id === teamId) if (team) { onTeamSelected(team) // Establecer como equipo por defecto si no lo es if (!team.is_default) { try { await setDefaultTeam(teamId) await loadTeams() // Recargar para actualizar el estado } catch (error) { console.error("Error setting default team:", error) } } } } const handleCreateTeam = async () => { if (!newTeamName.trim()) return try { const newTeam = await createTeam({ name: newTeamName.trim(), sport: newTeamSport, season: new Date().getFullYear().toString(), description: `Equipo creado el ${new Date().toLocaleDateString()}`, }) await loadTeams() onTeamSelected(newTeam) setIsCreateDialogOpen(false) setNewTeamName("") setNewTeamSport("Fútbol") } catch (error) { console.error("Error creating team:", error) } } if (loading) { return (

) } return ( Seleccionar Equipo Elige el equipo para cargar o visualizar datos. Tu primer equipo se guardará automáticamente. {teams.length > 0 ? ( <>

Equipo Actual

{selectedTeam && (

{selectedTeam.name}

{selectedTeam.is_default && ( Por defecto )}

Deporte: {selectedTeam.sport}

Temporada: {selectedTeam.season}

Creado: {new Date(selectedTeam.created_at).toLocaleDateString()}

)} ) : (

No tienes equipos

Crea tu primer equipo para comenzar a usar el dashboard

)} ) } [V0_FILE]typescriptreact:file="components/file-upload.tsx" isEdit="true" "use client" import { useState, useCallback } from "react" import { useDropzone } from "react-dropzone" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Alert, AlertDescription } from "@/components/ui/alert" import { Progress } from "@/components/ui/progress" import { FileSpreadsheet, Upload, CheckCircle, AlertCircle, Loader2, Download, Eye, History } from "lucide-react" import { processFile, processTeamData, type RawPlayerData, type ProcessedPlayerData, type TeamStats, } from "@/lib/file-processor" import { savePlayersData, type Team } from "@/lib/supabase-helpers" interface FileUploadProps { onDataProcessed: (players: ProcessedPlayerData[], teamStats: TeamStats) => void selectedTeam: Team | null } export function FileUpload({ onDataProcessed, selectedTeam }: FileUploadProps) { const [isProcessing, setIsProcessing] = useState(false) const [progress, setProgress] = useState(0) const [error, setError] = useState(null) const [success, setSuccess] = useState(null) const [teamName, setTeamName] = useState("") const [previewData, setPreviewData] = useState(null) const [processedData, setProcessedData] = useState<{ players: ProcessedPlayerData[] teamStats: TeamStats } | null>(null) const [fileName, setFileName] = useState("") const onDrop = useCallback( async (acceptedFiles: File[]) => { const file = acceptedFiles[0] if (!file) return setIsProcessing(true) setError(null) setSuccess(null) setProgress(0) setFileName(file.name) try { setProgress(25) // Procesar archivo const rawData = await processFile(file) setProgress(50) // Mostrar preview setPreviewData(rawData) setProgress(75) // Procesar datos del equipo const processed = processTeamData(rawData) setProcessedData(processed) setProgress(100) // Si hay un equipo seleccionado, usar su nombre por defecto if (selectedTeam && !teamName) { setTeamName(selectedTeam.name) } setSuccess(`Archivo procesado exitosamente. ${rawData.length} jugadores encontrados.`) } catch (err) { setError(err instanceof Error ? err.message : "Error procesando el archivo") } finally { setIsProcessing(false) } }, [selectedTeam, teamName], ) const { getRootProps, getInputProps, isDragActive } = useDropzone({ onDrop, accept: { "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": [".xlsx"], "application/vnd.ms-excel": [".xls"], "text/csv": [".csv"], }, maxFiles: 1, disabled: isProcessing, }) const handleSaveToDatabase = async () => { if (!processedData || !previewData) { setError("No hay datos para guardar") return } const finalTeamName = teamName.trim() || selectedTeam?.name || "Mi Equipo" setIsProcessing(true) setError(null) try { await savePlayersData( previewData, finalTeamName, fileName, selectedTeam?.id, // Si hay equipo seleccionado, actualizar; si no, crear nuevo ) // Pasar datos procesados al componente padre onDataProcessed(processedData.players, processedData.teamStats) setSuccess( selectedTeam ? `Datos actualizados exitosamente en ${selectedTeam.name}` : `Equipo "${finalTeamName}" creado y datos guardados exitosamente`, ) // Limpiar estado setPreviewData(null) setProcessedData(null) setTeamName("") setFileName("") } catch (err) { setError(err instanceof Error ? err.message : "Error guardando en la base de datos") } finally { setIsProcessing(false) } } const downloadTemplate = () => { const template = [ ["Nombre del Jugador", "Posición", "CMJ (cm)", "SJ (cm)", "DJ (cm)", "RSI", "Tiempo Contacto (s)"], ["Juan Pérez", "Delantero", "45.2", "38.1", "42.8", "1.85", "0.245"], ["Carlos López", "Centrocampista", "41,8", "36,5", "39,2", "1,72", "0,268"], ["Miguel Torres", "Defensor", "38.9", "34.2", "36.5", "1.58", "0.289"], ["Ana García", "Portera", "35.6", "31.8", "33.1", "1.45", "0.312"], ] const csvContent = template.map((row) => row.join(",")).join("\n") const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" }) const url = window.URL.createObjectURL(blob) const a = document.createElement("a") a.href = url a.download = "plantilla_analisis_saltos.csv" a.click() window.URL.revokeObjectURL(url) } return (

{/* Información del equipo seleccionado */} {selectedTeam && ( Actualizando: {selectedTeam.name} Los nuevos datos se agregarán a este equipo existente. Se mantendrá el historial de evaluaciones anteriores. )} {/* Sección de descarga de plantilla */} Plantilla de Datos Descarga la plantilla para asegurar el formato correcto de tus datos {/* Sección de carga de archivo */} Subir Archivo de Datos Sube un archivo Excel (.xlsx) o CSV con los datos de tus jugadores

{isDragActive ? (

Suelta el archivo aquí...

) : (

Arrastra y suelta tu archivo aquí, o haz clic para seleccionar

Formatos soportados: .xlsx, .xls, .csv

)}

{isProcessing && (

Procesando archivo...

)} {error && ( {error} )} {success && ( {success} )} {/* Preview de datos */} {previewData && ( Vista Previa de Datos Revisa los datos antes de guardar en la base de datos

{!selectedTeam && (

Nombre del Equipo setTeamName(e.target.value)} placeholder="Ej: Club Atlético River Plate" className="mt-1" />

)}

{previewData.slice(0, 10).map((player, index) => ( ))}

Nombre	Posición	CMJ	SJ	DJ	RSI	TC
{player.nombre}	{player.posicion}	{player.cmj}	{player.sj}	{player.dj}	{player.rsi}	{player.tc}

{previewData.length > 10 && (

... y {previewData.length - 10} jugadores más

)}

)} {/* Formato requerido */} Formato Flexible Aceptado El sistema acepta múltiples variaciones de nombres de columnas

Nombres de Columnas Aceptados:

Nombre del Jugador:

nombre, jugador, atleta, name, player

Posición:

posición, posicion, pos, position, puesto

CMJ:

CMJ, Counter Movement Jump, salto contramovimiento

SJ:

SJ, Squat Jump, salto cuclillas

Características Flexibles:

Acepta acentos y sin acentos

Español e inglés

Con o sin unidades (cm), (s)

Comas o puntos decimales

Espacios y caracteres especiales

Detección automática de encabezados

Ejemplos Válidos:

• "CMJ (cm)" → detectado como CMJ

• "Tiempo de Contacto" → detectado como TC

• "Posición de Juego" → detectado como Posición

• "1,85" o "1.85" → ambos válidos

) } [V0_FILE]typescriptreact:file="app/dashboard/page.tsx" isEdit="true" "use client" import { useState, useEffect } from "react" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Badge } from "@/components/ui/badge" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Upload, BarChart3, Users, TrendingUp, Database, History } from "lucide-react" import { PlayerAnalysis } from "@/components/player-analysis" import { TeamOverview } from "@/components/team-overview" import { RadarChart } from "@/components/radar-chart" import { FileUpload } from "@/components/file-upload" import { TeamSelector } from "@/components/team-selector" import Image from "next/image" import { JumpMetricsChart, DJvsRSIChart } from "@/components/area-charts" import type { ProcessedPlayerData, TeamStats } from "@/lib/file-processor" import { getLatestAnalysesByTeam, type Team } from "@/lib/supabase-helpers" export default function DashboardPage() { const [players, setPlayers] = useState([]) const [teamStats, setTeamStats] = useState(null) const [selectedPlayer, setSelectedPlayer] = useState("") const [activeTab, setActiveTab] = useState("upload") const [selectedTeam, setSelectedTeam] = useState(null) const [loading, setLoading] = useState(false) // Cargar datos cuando se selecciona un equipo useEffect(() => { if (selectedTeam) { loadTeamData(selectedTeam.id) } }, [selectedTeam]) const loadTeamData = async (teamId: string) => { try { setLoading(true) const analyses = await getLatestAnalysesByTeam(teamId) if (analyses.length > 0) { // Convertir análisis a formato ProcessedPlayerData const processedPlayers: ProcessedPlayerData[] = analyses.map((analysis: any) => ({ nombre: analysis.players.name, posicion: analysis.players.position || "Sin posición", cmj: analysis.cmj, sj: analysis.sj, dj: analysis.dj, rsi: analysis.rsi, tc: analysis.tc, eur: analysis.eur, zScores: { cmj: 0, // Se calculará después sj: 0, dj: 0, rsi: 0, tc: 0, eur: 0, }, })) // Calcular estadísticas del equipo const metrics = ["cmj", "sj", "dj", "rsi", "tc", "eur"] as const const stats: TeamStats = { mean: {} as any, std: {} as any, } metrics.forEach((metric) => { const values = processedPlayers.map((p) => p[metric] as number) const mean = values.reduce((a, b) => a + b, 0) / values.length const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / values.length const std = Math.sqrt(variance) stats.mean[metric] = mean stats.std[metric] = std }) // Calcular Z-scores processedPlayers.forEach((player) => { metrics.forEach((metric) => { const value = player[metric] as number const zScore = stats.std[metric] === 0 ? 0 : (value - stats.mean[metric]) / stats.std[metric] player.zScores![metric] = zScore }) }) setPlayers(processedPlayers) setTeamStats(stats) if (processedPlayers.length > 0) { setSelectedPlayer(processedPlayers[0].nombre) } setActiveTab("overview") } else { // No hay datos, mostrar tab de upload setPlayers([]) setTeamStats(null) setActiveTab("upload") } } catch (error) { console.error("Error loading team data:", error) } finally { setLoading(false) } } const handleDataProcessed = (processedPlayers: ProcessedPlayerData[], processedTeamStats: TeamStats) => { setPlayers(processedPlayers) setTeamStats(processedTeamStats) if (processedPlayers.length > 0) { setSelectedPlayer(processedPlayers[0].nombre) } setActiveTab("overview") } const handleTeamSelected = (team: Team | null) => { setSelectedTeam(team) if (!team) { setPlayers([]) setTeamStats(null) setActiveTab("upload") } } const selectedPlayerData = players.find((p) => p.nombre === selectedPlayer) return (

{/* Header */}

SLJ-Dashboard Pro

by Agustin Esterman Coach

Sistema profesional de análisis de saltos: CMJ, SJ, DJ, RSI y métricas especializadas

{/* Team Selector */}

{/* Dashboard Content */}

{/* Stats Overview - Solo mostrar si hay datos */} {players.length > 0 && teamStats && (

{players.length}

Jugadores

{teamStats.mean.cmj.toFixed(1)}

CMJ Promedio

{teamStats.mean.rsi.toFixed(2)}

RSI Promedio

Datos

)} {/* Loading State */} {loading && (

Cargando datos del equipo...

)} {/* Main Analysis */} {selectedTeam ? "Nueva Evaluación" : "Cargar Datos"} {players.length > 0 && ( <> Resumen del Equipo Análisis Individual Comparación Historial )} {players.length > 0 && teamStats && ( <>

Seleccionar Jugador:

{selectedPlayerData && }

{/* Gráficos de Área */}

Comparación de Saltos Verticales Análisis comparativo de CMJ, SJ y DJ por jugador

Drop Jump vs Índice de Fuerza Reactiva Relación entre capacidad de salto reactivo (DJ) y eficiencia (RSI)

{/* Gráfico Radar y Rankings */}

Gráfico Radar - Comparación Individual Comparación entre el promedio del equipo y el jugador seleccionado

Seleccionar Jugador:

{selectedPlayerData && } Ranking por Métrica Top 3 jugadores en cada métrica de rendimiento

{["cmj", "sj", "dj", "rsi", "eur"].map((metric) => (

{metric.toUpperCase()}

{players .sort( (a, b) => (b[metric as keyof ProcessedPlayerData] as number) - (a[metric as keyof ProcessedPlayerData] as number), ) .slice(0, 3) .map((player, index) => (

{index + 1} {player.nombre} {(player[metric as keyof ProcessedPlayerData] as number).toFixed(2)} {metric === "eur" ? "%" : metric === "cmj" || metric === "sj" || metric === "dj" ? " cm" : ""}

))}

{/* Análisis Estadístico Adicional */} Análisis Estadístico Avanzado Correlaciones y patrones identificados en los datos del equipo

Correlación CMJ-SJ

{(players.reduce((sum, p) => sum + p.cmj / p.sj, 0) / players.length).toFixed(2)}

Ratio promedio

Eficiencia DJ-RSI

{(players.reduce((sum, p) => sum + p.dj * p.rsi, 0) / players.length).toFixed(1)}

Índice combinado

Variabilidad EUR

{teamStats.std.eur.toFixed(1)}%

Desviación estándar

Historial de Evaluaciones Próximamente: Visualización del progreso histórico de tu equipo

Historial en Desarrollo

Esta funcionalidad mostrará la evolución de las métricas de tus jugadores a lo largo del tiempo.

Cada nueva evaluación que subas se guardará automáticamente para crear un historial completo.

)}

) }