97:I[903690,["/chat-static/_next/static/chunks/1hm3q0j7vx_jl.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/30cg74pivru03.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1v3tu-ayeqrg_.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2ir1-mfl-mxun.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3139m71i45f_m.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1d27q4_h4it5w.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/24itveg68o90k.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/10df6ghephwfh.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3g-fs4xgai-g5.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/45cgj0o2dd5ka.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1vo2s82fx-91j.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2b7mx-6g-n-p-.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3qbqqz-30yf_e.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0n2vqkuu3m7mv.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/151itv_w2dl-d.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2oig3hoirmj64.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1pzl0qjyusfha.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3nl30ufs08xyt.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1ilnu97ogkb5i.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0wkini5l9f_9s.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/11e80b-y89mrs.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1zvm-f33paz4c.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/43emq6v2fv13u.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/02rh369i5mh-5.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1rz_9ckgsy-eb.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2iu_2gtqlb9fh.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1e1jj32nu3059.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/054nyoml5t8yc.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0tmnhs5rj_pj7.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3z0af037uy3y2.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/130lebo2db7jj.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2ffzcp23_gird.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/311y33ni2zbzy.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0b2jr5pl--hcz.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3h4dxz6j9vrb9.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0ite474mxrjfz.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/22hg1dv7sryga.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2ak79vkcuz1ia.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2usqk7ipgup_t.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1qvyjk5p58sle.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3sty0m_bj1zjd.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/296n5x9xr-_1t.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3361kc_6h0dgd.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1hqlktk7lfas0.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0xushjtk7v84v.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2gyta6jpl0xuw.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2k7q8cwjrh5v9.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2x0r6v1gm-sbg.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0ri2k1_yh_pol.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1nep_-vv8ldmi.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0ws07icczx8x9.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh"],"ExplicitChatIdProvider"] 98:I[838238,["/chat-static/_next/static/chunks/1hm3q0j7vx_jl.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/30cg74pivru03.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1v3tu-ayeqrg_.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2ir1-mfl-mxun.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3139m71i45f_m.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1d27q4_h4it5w.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/24itveg68o90k.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/10df6ghephwfh.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3g-fs4xgai-g5.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/45cgj0o2dd5ka.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1vo2s82fx-91j.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2b7mx-6g-n-p-.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3qbqqz-30yf_e.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0n2vqkuu3m7mv.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/151itv_w2dl-d.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2oig3hoirmj64.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1pzl0qjyusfha.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3nl30ufs08xyt.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1ilnu97ogkb5i.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0wkini5l9f_9s.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/11e80b-y89mrs.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1zvm-f33paz4c.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/43emq6v2fv13u.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/02rh369i5mh-5.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1rz_9ckgsy-eb.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2iu_2gtqlb9fh.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1e1jj32nu3059.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/054nyoml5t8yc.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0tmnhs5rj_pj7.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3z0af037uy3y2.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/130lebo2db7jj.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2ffzcp23_gird.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/311y33ni2zbzy.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0b2jr5pl--hcz.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3h4dxz6j9vrb9.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0ite474mxrjfz.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/22hg1dv7sryga.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2ak79vkcuz1ia.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2usqk7ipgup_t.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1qvyjk5p58sle.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3sty0m_bj1zjd.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/296n5x9xr-_1t.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/3361kc_6h0dgd.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1hqlktk7lfas0.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0xushjtk7v84v.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2gyta6jpl0xuw.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2k7q8cwjrh5v9.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/2x0r6v1gm-sbg.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0ri2k1_yh_pol.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/1nep_-vv8ldmi.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh","/chat-static/_next/static/chunks/0ws07icczx8x9.js?dpl=dpl_DR81h1GYRPjyfohpJrqJPdbbayvh"],"SWRDataProvider"] 9a:[] 9b:[["Sgr9jnH0rJB","b_F6XdWL29UWG"],["b_PtoVFQXT5Eq",null]] 9c:[["Sgr9jnH0rJB",{"templateVersionId":null,"templateCanonId":null}],["b_PtoVFQXT5Eq",{"templateVersionId":null,"templateCanonId":null}]] 9d:[["Sgr9jnH0rJB","$D2025-06-05T18:27:59.343Z"],["b_PtoVFQXT5Eq","$D2025-06-21T13:45:19.145Z"]] 9e:[["Sgr9jnH0rJB",false],["b_PtoVFQXT5Eq",false]] 9f:[["Sgr9jnH0rJB",{"git":{"ref":"main","sha":"cb32f47f115dac18a34a64338996ca2a79cf0c8a","type":"github","repoId":0,"repoName":"omr-1w","ownerName":"khulnasoft-bot","commitMessage":"feat: fork OMR sheet generator project\n\nUpdate multiple components and utilities for new OMR functionality"},"deploymentId":"dpl_FVywFitxWycTYFepZwigJ6gPzL7n"}],["b_PtoVFQXT5Eq",{"git":{"ref":"main","sha":"8dad41a6001264c903263481c17a63a7b5237e42","type":"github","repoId":0,"repoName":"omr-1w","ownerName":"khulnasoft-bot","commitMessage":"Initialized repository for project OMR sheet generator\n\nCo-authored-by: KhulnaSoft bot <43526132+khulnasoft-bot@users.noreply.github.com>"},"deploymentId":"dpl_FVywFitxWycTYFepZwigJ6gPzL7n"}]] a0:[["Sgr9jnH0rJB",null],["b_PtoVFQXT5Eq",null]] a1:[["Sgr9jnH0rJB",true],["b_PtoVFQXT5Eq",true]] a2:[["Sgr9jnH0rJB",true],["b_PtoVFQXT5Eq",true]] a3:[] a4:T42cd6,[V0_FILE]plaintext:file=".gitignore" # See https://help.github.com/articles/ignoring-files/ for more about ignoring files. # dependencies /node_modules # next.js /.next/ /out/ # production /build # debug npm-debug.log* yarn-debug.log* yarn-error.log* .pnpm-debug.log* # env files .env* # vercel .vercel # typescript *.tsbuildinfo next-env.d.ts [V0_FILE]markdown:file="README.md" # OMR sheet generator *Automatically synced with your [v0.dev](https://v0.dev) deployments* [![Deployed on Vercel](https://img.shields.io/badge/Deployed%20on-Vercel-black?style=for-the-badge&logo=vercel)](https://vercel.com/khulnasoft-projects/bossomr) [![Built with v0](https://img.shields.io/badge/Built%20with-v0.dev-black?style=for-the-badge)](https://v0.dev/chat/projects/O3Rm6sdsWbF) ## Overview This repository will stay in sync with your deployed chats on [v0.dev](https://v0.dev). Any changes you make to your deployed app will be automatically pushed to this repository from [v0.dev](https://v0.dev). ## Deployment Your project is live at: **[https://vercel.com/khulnasoft-projects/bossomr](https://vercel.com/khulnasoft-projects/bossomr)** ## Build your app Continue building your app on: **[https://v0.dev/chat/projects/O3Rm6sdsWbF](https://v0.dev/chat/projects/O3Rm6sdsWbF)** ## How It Works 1. Create and modify your project using [v0.dev](https://v0.dev) 2. Deploy your chats from the v0 interface 3. Changes are automatically pushed to this repository 4. Vercel deploys the latest version from this repository [V0_FILE]css:file="app/globals.css" @tailwind base; @tailwind components; @tailwind utilities; @layer base { :root { --background: 0 0% 100%; --foreground: 222.2 84% 4.9%; --card: 0 0% 100%; --card-foreground: 222.2 84% 4.9%; --popover: 0 0% 100%; --popover-foreground: 222.2 84% 4.9%; --primary: 214 100% 48%; --primary-foreground: 210 40% 98%; --secondary: 210 40% 96.1%; --secondary-foreground: 222.2 47.4% 11.2%; --muted: 210 40% 96.1%; --muted-foreground: 215.4 16.3% 46.9%; --accent: 210 40% 96.1%; --accent-foreground: 222.2 47.4% 11.2%; --destructive: 0 84.2% 60.2%; --destructive-foreground: 210 40% 98%; --border: 214.3 31.8% 91.4%; --input: 214.3 31.8% 91.4%; --ring: 214 100% 48%; --radius: 0.5rem; } .dark { --background: 222.2 84% 4.9%; --foreground: 210 40% 98%; --card: 222.2 84% 4.9%; --card-foreground: 210 40% 98%; --popover: 222.2 84% 4.9%; --popover-foreground: 210 40% 98%; --primary: 214 100% 48%; --primary-foreground: 210 40% 98%; --secondary: 217.2 32.6% 17.5%; --secondary-foreground: 210 40% 98%; --muted: 217.2 32.6% 17.5%; --muted-foreground: 215 20.2% 65.1%; --accent: 217.2 32.6% 17.5%; --accent-foreground: 210 40% 98%; --destructive: 0 62.8% 30.6%; --destructive-foreground: 210 40% 98%; --border: 217.2 32.6% 17.5%; --input: 217.2 32.6% 17.5%; --ring: 214 100% 48%; } } @layer base { * { @apply border-border; } body { @apply bg-background text-foreground; font-feature-settings: "rlig" 1, "calt" 1; } } .glass-card { background: rgba(18, 18, 18, 0.7); backdrop-filter: blur(10px); border: 1px solid rgba(255, 255, 255, 0.1); box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2); } .glass-panel { background: rgba(30, 30, 30, 0.6); backdrop-filter: blur(8px); border: 1px solid rgba(255, 255, 255, 0.08); } .blue-glow { box-shadow: 0 0 15px rgba(0, 112, 243, 0.5); } .grid-pattern { background-image: linear-gradient(rgba(255, 255, 255, 0.05) 1px, transparent 1px), linear-gradient(90deg, rgba(255, 255, 255, 0.05) 1px, transparent 1px); background-size: 20px 20px; } [V0_FILE]typescriptreact:file="app/layout.tsx" import type React from "react" import "@/app/globals.css" import { Inter } from "next/font/google" import { ThemeProvider } from "@/components/theme-provider" const inter = Inter({ subsets: ["latin"] }) export default function RootLayout({ children }: { children: React.ReactNode }) { return ( OMR Sheet Generator {children} ) } export const metadata = { generator: 'v0.dev' }; [V0_FILE]typescriptreact:file="app/page.tsx" import { OMRSheetGenerator } from "@/components/omr-sheet-generator" export default function Home() { return (

OMR Sheet Generator

Create customizable optical mark recognition sheets for exams, surveys, and assessments

) } [V0_FILE]json:file="components.json" { "$schema": "https://ui.shadcn.com/schema.json", "style": "default", "rsc": true, "tsx": true, "tailwind": { "config": "tailwind.config.ts", "css": "app/globals.css", "baseColor": "neutral", "cssVariables": true, "prefix": "" }, "aliases": { "components": "@/components", "utils": "@/lib/utils", "ui": "@/components/ui", "lib": "@/lib", "hooks": "@/hooks" }, "iconLibrary": "lucide" } [V0_FILE]typescriptreact:file="components/analytics-dashboard.tsx" "use client" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, PieChart, Pie, Cell, LineChart, Line, } from "recharts" import { TrendingUp, Users, Target, Award, AlertTriangle, CheckCircle } from "lucide-react" interface StudentResponse { id: string name: string rollNumber: string responses: Record score: number percentage: number timestamp: Date } interface AnalyticsDashboardProps { config: { title: string numQuestions: number optionsPerQuestion: number uniqueId: string } answerKey: Record studentResponses: StudentResponse[] } export function AnalyticsDashboard({ config, answerKey, studentResponses }: AnalyticsDashboardProps) { const optionLetters = ["A", "B", "C", "D", "E"] const getScoreDistribution = () => { const ranges = [ { range: "0-20%", min: 0, max: 20, count: 0 }, { range: "21-40%", min: 21, max: 40, count: 0 }, { range: "41-60%", min: 41, max: 60, count: 0 }, { range: "61-80%", min: 61, max: 80, count: 0 }, { range: "81-100%", min: 81, max: 100, count: 0 }, ] studentResponses.forEach((response) => { const range = ranges.find((r) => response.percentage >= r.min && response.percentage <= r.max) if (range) range.count++ }) return ranges } const getQuestionAnalysis = () => { const analysis: Array<{ question: number correctAnswers: number incorrectAnswers: number difficulty: string optionDistribution: Record }> = [] for (let i = 1; i <= config.numQuestions; i++) { const correctAnswer = answerKey[i] let correctCount = 0 let incorrectCount = 0 const optionDistribution: Record = {} // Initialize option distribution optionLetters.slice(0, config.optionsPerQuestion).forEach((option) => { optionDistribution[option] = 0 }) studentResponses.forEach((response) => { const studentAnswer = response.responses[i] if (studentAnswer) { optionDistribution[studentAnswer] = (optionDistribution[studentAnswer] || 0) + 1 if (correctAnswer && studentAnswer === correctAnswer) { correctCount++ } else { incorrectCount++ } } }) const totalResponses = correctCount + incorrectCount const difficultyPercentage = totalResponses > 0 ? (correctCount / totalResponses) * 100 : 0 let difficulty = "Easy" if (difficultyPercentage < 30) difficulty = "Hard" else if (difficultyPercentage < 70) difficulty = "Medium" analysis.push({ question: i, correctAnswers: correctCount, incorrectAnswers: incorrectCount, difficulty, optionDistribution, }) } return analysis } const getAnswerKeyDistribution = () => { const distribution: Record = {} optionLetters.slice(0, config.optionsPerQuestion).forEach((option) => { distribution[option] = 0 }) Object.values(answerKey).forEach((answer) => { distribution[answer] = (distribution[answer] || 0) + 1 }) return Object.entries(distribution).map(([option, count]) => ({ option, count, })) } const getPerformanceTrend = () => { return studentResponses .slice() .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime()) .map((response, index) => ({ submission: index + 1, percentage: response.percentage, name: response.name, })) } const getTopPerformers = () => { return studentResponses .slice() .sort((a, b) => b.percentage - a.percentage) .slice(0, 5) } const getStatistics = () => { if (studentResponses.length === 0) { return { averageScore: 0, highestScore: 0, lowestScore: 0, passRate: 0, totalStudents: 0, } } const scores = studentResponses.map((r) => r.percentage) const averageScore = Math.round(scores.reduce((sum, score) => sum + score, 0) / scores.length) const highestScore = Math.max(...scores) const lowestScore = Math.min(...scores) const passRate = Math.round((scores.filter((score) => score >= 60).length / scores.length) * 100) return { averageScore, highestScore, lowestScore, passRate, totalStudents: studentResponses.length, } } const scoreDistribution = getScoreDistribution() const questionAnalysis = getQuestionAnalysis() const answerKeyDistribution = getAnswerKeyDistribution() const performanceTrend = getPerformanceTrend() const topPerformers = getTopPerformers() const statistics = getStatistics() const COLORS = ["#0070f3", "#00d4aa", "#ff6b6b", "#ffd93d", "#6c5ce7"] const hardQuestions = questionAnalysis.filter((q) => q.difficulty === "Hard").slice(0, 5) const easyQuestions = questionAnalysis.filter((q) => q.difficulty === "Easy").slice(0, 5) return (

{/* Key Statistics */}

{statistics.totalStudents}

Total Students

{statistics.averageScore}%

Average Score

{statistics.highestScore}%

Highest Score

{statistics.lowestScore}%

Lowest Score

{statistics.passRate}%

Pass Rate

{/* Score Distribution */} Score Distribution {/* Answer Key Distribution */} Answer Key Distribution `${option}: ${count}`} outerRadius={80} fill="#8884d8" dataKey="count" > {answerKeyDistribution.map((entry, index) => ( ))}

{/* Performance Trend */} {performanceTrend.length > 0 && ( Performance Trend )}

{/* Top Performers */} Top Performers

{topPerformers.length === 0 ? (

No data available

) : ( topPerformers.map((student, index) => (

#{index + 1}

{student.name}

Roll: {student.rollNumber}

{student.percentage}%

)) )}

{/* Difficult Questions */} Most Difficult Questions

{hardQuestions.length === 0 ? (

No difficult questions identified

) : ( hardQuestions.map((question) => (

Question {question.question} {question.difficulty}

Correct: {question.correctAnswers} | Incorrect: {question.incorrectAnswers}

Success Rate:{" "} {question.correctAnswers + question.incorrectAnswers > 0 ? Math.round( (question.correctAnswers / (question.correctAnswers + question.incorrectAnswers)) * 100, ) : 0} %

)) )}

{/* Easy Questions */} Easiest Questions

{easyQuestions.length === 0 ? (

No easy questions identified

) : ( easyQuestions.map((question) => (

Question {question.question} {question.difficulty}

Correct: {question.correctAnswers} | Incorrect: {question.incorrectAnswers}

Success Rate:{" "} {question.correctAnswers + question.incorrectAnswers > 0 ? Math.round( (question.correctAnswers / (question.correctAnswers + question.incorrectAnswers)) * 100, ) : 0} %

)) )}

{/* Question-wise Analysis */} {questionAnalysis.length > 0 && ( Question-wise Performance Analysis

Question

Correct

Incorrect

Success Rate

Difficulty

Answer Key

{questionAnalysis.map((question) => { const totalResponses = question.correctAnswers + question.incorrectAnswers const successRate = totalResponses > 0 ? Math.round((question.correctAnswers / totalResponses) * 100) : 0 return (

{question.question}

{question.correctAnswers}

{question.incorrectAnswers}

{successRate}%

{question.difficulty}

{answerKey[question.question] || "-"}

) })}

)}

) } [V0_FILE]typescriptreact:file="components/answer-key-comparison.tsx" "use client" import { useState } from "react" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Badge } from "@/components/ui/badge" import { Textarea } from "@/components/ui/textarea" import { Alert, AlertDescription } from "@/components/ui/alert" import { GitCompare, Download, AlertTriangle } from "lucide-react" interface AnswerKeyComparisonProps { config: { title: string numQuestions: number optionsPerQuestion: number uniqueId: string } primaryAnswers: Record onAnswerChange: (questionNum: number, answer: string) => void } export function AnswerKeyComparison({ config, primaryAnswers, onAnswerChange }: AnswerKeyComparisonProps) { const [secondaryAnswers, setSecondaryAnswers] = useState>({}) const [comparisonName, setComparisonName] = useState("Comparison Answer Key") const [importText, setImportText] = useState("") const optionLetters = ["A", "B", "C", "D", "E"] const parseImportText = (text: string) => { if (!text.trim()) return try { const lines = text.trim().split("\n") const parsed: Record = {} const validOptions = optionLetters.slice(0, config.optionsPerQuestion) const firstLine = lines[0].trim() if (firstLine.includes(",") || firstLine.includes("\t")) { lines.forEach((line, index) => { const parts = line.split(/[,\t]/).map((p) => p.trim()) if (parts.length >= 2) { const questionNum = Number.parseInt(parts[0].replace(/\D/g, "")) || index + 1 const answer = parts[1].toUpperCase() if (questionNum <= config.numQuestions && validOptions.includes(answer)) { parsed[questionNum] = answer } } else if (parts.length === 1 && parts[0]) { const questionNum = index + 1 const answer = parts[0].toUpperCase() if (questionNum <= config.numQuestions && validOptions.includes(answer)) { parsed[questionNum] = answer } } }) } else { const cleanText = text.replace(/\s+/g, "").toUpperCase() if (cleanText.length <= config.numQuestions) { for (let i = 0; i < cleanText.length && i < config.numQuestions; i++) { const answer = cleanText[i] if (validOptions.includes(answer)) { parsed[i + 1] = answer } } } else { const answers = text .trim() .split(/\s+/) .map((a) => a.toUpperCase()) answers.forEach((answer, index) => { const questionNum = index + 1 if (questionNum <= config.numQuestions && validOptions.includes(answer)) { parsed[questionNum] = answer } }) } } setSecondaryAnswers(parsed) } catch (error) { console.error("Error parsing answers:", error) } } const clearSecondary = () => { setSecondaryAnswers({}) setImportText("") } const copyFromPrimary = () => { setSecondaryAnswers({ ...primaryAnswers }) } const exportComparison = () => { const differences = getDifferences() let csvContent = "Question,Primary Answer,Secondary Answer,Match\n" for (let i = 1; i <= config.numQuestions; i++) { const primary = primaryAnswers[i] || "-" const secondary = secondaryAnswers[i] || "-" const match = primary === secondary ? "Yes" : "No" csvContent += `${i},${primary},${secondary},${match}\n` } const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" }) const url = URL.createObjectURL(blob) const link = document.createElement("a") link.setAttribute("href", url) link.setAttribute("download", `answer_key_comparison_${config.uniqueId}.csv`) link.style.visibility = "hidden" document.body.appendChild(link) link.click() document.body.removeChild(link) } const getDifferences = () => { const differences: Array<{ question: number primary: string secondary: string }> = [] for (let i = 1; i <= config.numQuestions; i++) { const primary = primaryAnswers[i] const secondary = secondaryAnswers[i] if (primary && secondary && primary !== secondary) { differences.push({ question: i, primary, secondary, }) } } return differences } const getStatistics = () => { const primaryCount = Object.keys(primaryAnswers).length const secondaryCount = Object.keys(secondaryAnswers).length const differences = getDifferences() const matches = Math.min(primaryCount, secondaryCount) - differences.length return { primaryCount, secondaryCount, matches, differences: differences.length, accuracy: secondaryCount > 0 ? Math.round((matches / Math.min(primaryCount, secondaryCount)) * 100) : 0, } } const statistics = getStatistics() const differences = getDifferences() return (

Answer Key Comparison

Comparison Name setComparisonName(e.target.value)} className="bg-black/40 border-gray-700" />

Import Secondary Answer Key

{
                setImportText(e.target.value)
                parseImportText(e.target.value)
              }}
              placeholder="Paste answers here (CSV, plain text, or space-separated)..."
              className="h-32 bg-black/40 border-gray-700 text-white"
            />
          </div>

<div className="grid grid-cols-2 gap-3">
            <Button
              variant="outline"
              onClick={copyFromPrimary}
              className="border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white"
            >
              Copy Primary
            </Button>
            <Button
              variant="outline"
              onClick={clearSecondary}
              className="border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white"
            >
              Clear Secondary
            </Button>
          </div>

<div className="bg-[#0070f3]/10 p-4 rounded-lg border border-[#0070f3]/20">
            <h3 className="font-medium mb-3 text-white">Comparison Statistics</h3>
            <div className="grid grid-cols-2 gap-4 text-sm">
              <div>
                <span className="text-gray-300">Primary Answers:</span>
                <span className="ml-2 text-white font-medium">{statistics.primaryCount}</span>
              </div>
              <div>
                <span className="text-gray-300">Secondary Answers:</span>
                <span className="ml-2 text-white font-medium">{statistics.secondaryCount}</span>
              </div>
              <div>
                <span className="text-gray-300">Matches:</span>
                <span className="ml-2 text-green-400 font-medium">{statistics.matches}</span>
              </div>
              <div>
                <span className="text-gray-300">Differences:</span>
                <span className="ml-2 text-red-400 font-medium">{statistics.differences}</span>
              </div>
            </div>
            <div className="mt-3 pt-3 border-t border-[#0070f3]/20">
              <span className="text-gray-300">Accuracy:</span>
              <span className="ml-2 text-[#0070f3] font-bold text-lg">{statistics.accuracy}%</span>
            </div>
          </div>

{differences.length > 0 && (
            <Alert className="bg-amber-900/20 border-amber-900/50">
              <AlertTriangle className="h-4 w-4" />
              <AlertDescription>
                <div className="text-amber-200">
                  <p className="font-medium mb-2">{differences.length} differences found:</p>
                  <div className="max-h-32 overflow-y-auto space-y-1">
                    {differences.map(({ question, primary, secondary }) => (
                      <div key={question} className="text-xs">
                        Q{question}: {primary} → {secondary}
                      </div>
                    ))}
                  </div>
                </div>
              </AlertDescription>
            </Alert>
          )}

<Button
            className="w-full bg-[#0070f3] hover:bg-[#0060d3]"
            onClick={exportComparison}
            disabled={Object.keys(secondaryAnswers).length === 0}
          >
            <Download size={16} className="mr-2" />
            Export Comparison
          </Button>
        </CardContent>
      </Card>

<Card className="glass-card border-0">
        <CardHeader className="border-b border-gray-800">
          <CardTitle className="text-white">Side-by-Side Comparison</CardTitle>
        </CardHeader>
        <CardContent className="pt-6">
          <div className="max-h-[600px] overflow-y-auto">
            <div className="grid grid-cols-4 gap-2 text-xs font-bold mb-2 sticky top-0 bg-black/80 p-2 rounded">
              <div className="text-gray-300">Q#</div>
              <div className="text-blue-400">Primary</div>
              <div className="text-purple-400">Secondary</div>
              <div className="text-gray-300">Match</div>
            </div>

<div className="space-y-1">
              {Array.from({ length: config.numQuestions }, (_, i) => {
                const questionNum = i + 1
                const primary = primaryAnswers[questionNum]
                const secondary = secondaryAnswers[questionNum]
                const match = primary && secondary ? primary === secondary : null

return (
                  <div
                    key={questionNum}
                    className={`grid grid-cols-4 gap-2 text-sm p-2 rounded ${
                      match === false ? "bg-red-900/20 border border-red-900/50" : "bg-black/20"
                    }`}
                  >
                    <div className="text-gray-300 font-medium">{questionNum}</div>
                    <div className="text-blue-400">{primary || "-"}</div>
                    <div className="text-purple-400">{secondary || "-"}</div>
                    <div>
                      {match === true && (
                        <Badge className="bg-green-900/30 text-green-400 border-green-900/50">✓</Badge>
                      )}
                      {match === false && <Badge className="bg-red-900/30 text-red-400 border-red-900/50">✗</Badge>}
                      {match === null && (
                        <Badge variant="outline" className="border-gray-700 text-gray-500">
                          -
                        </Badge>
                      )}
                    </div>
                  </div>
                )
              })}
            </div>
          </div>
        </CardContent>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/answer-key-generator.tsx"
"use client"

import type React from "react"

import { useRef, useState } from "react"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
import { AnswerKey } from "@/components/answer-key"
import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from "@/components/ui/dialog"
import { Textarea } from "@/components/ui/textarea"
import { Alert, AlertDescription } from "@/components/ui/alert"
import { AlertCircle, FileDown, FileUp, XCircle, RotateCw, Repeat, ArrowDownUp, Shuffle } from "lucide-react"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { Badge } from "@/components/ui/badge"

interface AnswerKeyGeneratorProps {
  config: {
    title: string
    numQuestions: number
    optionsPerQuestion: number
    showRollNumber: boolean
    showName: boolean
    showInstructions: boolean
    uniqueId: string
  }
  answers: Record<number, string>
  onAnswerChange: (questionNum: number, answer: string) => void
  onClearAll: () => void
  onGenerateRandom: () => void
}

interface AnswerPattern {
  name: string
  description: string
  icon: React.ReactNode
  generate: (numQuestions: number, optionsPerQuestion: number) => Record<number, string>
}

export function AnswerKeyGenerator({
  config,
  answers,
  onAnswerChange,
  onClearAll,
  onGenerateRandom,
}: AnswerKeyGeneratorProps) {
  const answerKeyRef = useRef<HTMLDivElement>(null)
  const [importDialog, setImportDialog] = useState(false)
  const [importText, setImportText] = useState("")
  const [importPreview, setImportPreview] = useState<Record<number, string>>({})
  const [importError, setImportError] = useState("")
  const [validationResults, setValidationResults] = useState<{
    duplicates: number[]
    missing: number[]
    invalid: Array<{ question: number; value: string }>
  }>({
    duplicates: [],
    missing: [],
    invalid: [],
  })
  const optionLetters = ["A", "B", "C", "D", "E"]

const answerPatterns: AnswerPattern[] = [
    {
      name: "Sequential",
      description: "A, B, C, D, A, B, C, D...",
      icon: <Repeat size={16} />,
      generate: (numQuestions, optionsPerQuestion) => {
        const result: Record<number, string> = {}
        for (let i = 1; i <= numQuestions; i++) {
          const index = (i - 1) % optionsPerQuestion
          result[i] = optionLetters[index]
        }
        return result
      },
    },
    {
      name: "Alternating",
      description: "A, B, A, B, A, B...",
      icon: <ArrowDownUp size={16} />,
      generate: (numQuestions, optionsPerQuestion) => {
        const result: Record<number, string> = {}
        for (let i = 1; i <= numQuestions; i++) {
          const index = (i - 1) % 2
          result[i] = optionLetters[index]
        }
        return result
      },
    },
    {
      name: "Random",
      description: "Randomly generated answers",
      icon: <Shuffle size={16} />,
      generate: (numQuestions, optionsPerQuestion) => {
        const result: Record<number, string> = {}
        for (let i = 1; i <= numQuestions; i++) {
          const index = Math.floor(Math.random() * optionsPerQuestion)
          result[i] = optionLetters[index]
        }
        return result
      },
    },
    {
      name: "All Same",
      description: "All answers set to the same option",
      icon: <RotateCw size={16} />,
      generate: (numQuestions, optionsPerQuestion) => {
        const result: Record<number, string> = {}
        const index = Math.floor(Math.random() * optionsPerQuestion)
        for (let i = 1; i <= numQuestions; i++) {
          result[i] = optionLetters[index]
        }
        return result
      },
    },
  ]

const handlePrintAnswerKey = () => {
    const printContent = answerKeyRef.current
    if (!printContent) return

const printWindow = window.open("", "_blank")
    if (!printWindow) return

printWindow.document.write(`
    <!DOCTYPE html>
    <html>
      <head>
        <title>Answer Key - ${config.title}</title>
        <style>
          body { margin: 0; padding: 20px; font-family: Inter, sans-serif; background: white; color: black; }
          @media print {
            body { margin: 0; padding: 0; }
            .no-print { display: none; }
          }
          .border-2 { border: 2px solid black; }
          .border { border: 1px solid black; }
          .border-b-2 { border-bottom: 2px solid black; }
          .p-6 { padding: 24px; }
          .p-4 { padding: 16px; }
          .py-4 { padding-top: 16px; padding-bottom: 16px; }
          .pb-4 { padding-bottom: 16px; }
          .mb-4 { margin-bottom: 16px; }
          .mb-2 { margin-bottom: 8px; }
          .mb-1 { margin-bottom: 4px; }
          .mr-2 { margin-right: 8px; }
          .mr-4 { margin-right: 16px; }
          .mt-1 { margin-top: 4px; }
          .text-center { text-align: center; }
          .text-right { text-align: right; }
          .text-2xl { font-size: 24px; }
          .text-lg { font-size: 18px; }
          .text-sm { font-size: 14px; }
          .font-bold { font-weight: bold; }
          .font-medium { font-weight: 500; }
          .flex { display: flex; }
          .items-center { align-items: center; }
          .justify-between { justify-content: space-between; }
          .grid { display: grid; }
          .grid-cols-1 { grid-template-columns: repeat(1, minmax(0, 1fr)); }
          .grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
          .grid-cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
          .grid-cols-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
          .grid-cols-5 { grid-template-columns: repeat(5, minmax(0, 1fr)); }
          .gap-4 { gap: 16px; }
          .gap-x-8 { column-gap: 32px; }
          .gap-y-2 { row-gap: 8px; }
          .w-full { width: 100%; }
          .w-8 { width: 32px; }
          .bg-green-100 { background-color: #dcfce7; }
          .text-green-800 { color: #166534; }
          .rounded { border-radius: 4px; }
          @media (min-width: 768px) {
            .md\\:grid-cols-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
            .md\\:grid-cols-5 { grid-template-columns: repeat(5, minmax(0, 1fr)); }
          }
          @media (min-width: 1024px) {
            .lg\\:grid-cols-5 { grid-template-columns: repeat(5, minmax(0, 1fr)); }
            .lg\\:grid-cols-6 { grid-template-columns: repeat(6, minmax(0, 1fr)); }
          }
        </style>
      </head>
      <body>
        ${printContent.innerHTML}
      </body>
    </html>
  `)

printWindow.document.close()
    printWindow.focus()
    setTimeout(() => {
      printWindow.print()
      printWindow.close()
    }, 250)
  }

const handleFileUpload = (event: React.ChangeEvent<HTMLInputElement>) => {
    const file = event.target.files?.[0]
    if (!file) return

const reader = new FileReader()
    reader.onload = (e) => {
      const content = e.target?.result as string
      setImportText(content)
      parseImportText(content)
    }
    reader.readAsText(file)
  }

const parseImportText = (text: string) => {
    setImportError("")
    setImportPreview({})
    setValidationResults({
      duplicates: [],
      missing: [],
      invalid: [],
    })

if (!text.trim()) return

try {
      const lines = text.trim().split("\n")
      const parsed: Record<number, string> = {}
      const validOptions = optionLetters.slice(0, config.optionsPerQuestion)
      const duplicates: number[] = []
      const invalid: Array<{ question: number; value: string }> = []

// Try to detect format
      const firstLine = lines[0].trim()

if (firstLine.includes(",") || firstLine.includes("\t")) {
        // CSV format: "1,A" or "Question 1,A" or just "A,B,C,D..."
        lines.forEach((line, index) => {
          const parts = line.split(/[,\t]/).map((p) => p.trim())

if (parts.length >= 2) {
            // Format: "1,A" or "Question 1,A"
            const questionNum = Number.parseInt(parts[0].replace(/\D/g, "")) || index + 1
            const answer = parts[1].toUpperCase()

if (questionNum <= config.numQuestions) {
              if (validOptions.includes(answer)) {
                if (parsed[questionNum]) {
                  duplicates.push(questionNum)
                }
                parsed[questionNum] = answer
              } else {
                invalid.push({ question: questionNum, value: answer })
              }
            }
          } else if (parts.length === 1 && parts[0]) {
            // Format: Single column of answers "A\nB\nC..."
            const questionNum = index + 1
            const answer = parts[0].toUpperCase()

if (questionNum <= config.numQuestions) {
              if (validOptions.includes(answer)) {
                parsed[questionNum] = answer
              } else {
                invalid.push({ question: questionNum, value: answer })
              }
            }
          }
        })
      } else {
        // Plain text format: "ABCDABCD..." or "A B C D A B C D..."
        const cleanText = text.replace(/\s+/g, "").toUpperCase()

if (cleanText.length <= config.numQuestions) {
          // Single string of answers
          for (let i = 0; i < cleanText.length && i < config.numQuestions; i++) {
            const answer = cleanText[i]
            if (validOptions.includes(answer)) {
              parsed[i + 1] = answer
            } else {
              invalid.push({ question: i + 1, value: answer })
            }
          }
        } else {
          // Space-separated answers
          const answers = text
            .trim()
            .split(/\s+/)
            .map((a) => a.toUpperCase())
          answers.forEach((answer, index) => {
            const questionNum = index + 1
            if (questionNum <= config.numQuestions) {
              if (validOptions.includes(answer)) {
                parsed[questionNum] = answer
              } else {
                invalid.push({ question: questionNum, value: answer })
              }
            }
          })
        }
      }

// Find missing questions
      const missing: number[] = []
      for (let i = 1; i <= config.numQuestions; i++) {
        if (!parsed[i]) {
          missing.push(i)
        }
      }

setValidationResults({
        duplicates,
        missing,
        invalid,
      })

if (Object.keys(parsed).length === 0) {
        setImportError("No valid answers found. Please check your format.")
      } else {
        setImportPreview(parsed)
      }
    } catch (error) {
      setImportError("Error parsing file. Please check the format.")
    }
  }

const applyImportedAnswers = () => {
    Object.entries(importPreview).forEach(([questionNum, answer]) => {
      onAnswerChange(Number.parseInt(questionNum), answer)
    })
    setImportDialog(false)
    setImportText("")
    setImportPreview({})
    setImportError("")
    setValidationResults({
      duplicates: [],
      missing: [],
      invalid: [],
    })
  }

const clearImport = () => {
    setImportText("")
    setImportPreview({})
    setImportError("")
    setValidationResults({
      duplicates: [],
      missing: [],
      invalid: [],
    })
  }

const exportToCSV = () => {
    if (Object.keys(answers).length === 0) return

let csvContent = "Question,Answer\n"

Object.entries(answers)
      .sort(([a], [b]) => Number.parseInt(a) - Number.parseInt(b))
      .forEach(([questionNum, answer]) => {
        csvContent += `${questionNum},${answer}\n`
      })

const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" })
    const url = URL.createObjectURL(blob)
    const link = document.createElement("a")
    link.setAttribute("href", url)
    link.setAttribute("download", `${config.title.replace(/\s+/g, "_")}_answers.csv`)
    link.style.visibility = "hidden"
    document.body.appendChild(link)
    link.click()
    document.body.removeChild(link)
  }

const applyPattern = (pattern: AnswerPattern) => {
    const newAnswers = pattern.generate(config.numQuestions, config.optionsPerQuestion)
    Object.entries(newAnswers).forEach(([questionNum, answer]) => {
      onAnswerChange(Number.parseInt(questionNum), answer)
    })
  }

const answeredQuestions = Object.keys(answers).length
  const completionPercentage = Math.round((answeredQuestions / config.numQuestions) * 100)

return (
    <div className="grid md:grid-cols-2 gap-8">
      <Card className="glass-card border-0">
        <CardHeader className="border-b border-gray-800">
          <CardTitle className="text-white">Answer Key Configuration</CardTitle>
        </CardHeader>
        <CardContent className="space-y-6 pt-6">
          <div className="bg-[#0070f3]/10 p-4 rounded-lg border border-[#0070f3]/20">
            <h3 className="font-medium mb-2 text-white">Progress</h3>
            <p className="text-sm text-gray-300">
              {answeredQuestions} of {config.numQuestions} questions answered ({completionPercentage}%)
            </p>
            <div className="w-full bg-gray-800 rounded-full h-2 mt-2">
              <div
                className="bg-[#0070f3] h-2 rounded-full transition-all duration-300 blue-glow"
                style={{ width: `${completionPercentage}%` }}
              ></div>
            </div>
          </div>

<Tabs defaultValue="actions" className="w-full">
            <TabsList className="grid grid-cols-3 mb-4 bg-black/40">
              <TabsTrigger value="actions">Actions</TabsTrigger>
              <TabsTrigger value="patterns">Patterns</TabsTrigger>
              <TabsTrigger value="answers">Answers</TabsTrigger>
            </TabsList>

<TabsContent value="actions" className="space-y-4">
              <div className="grid grid-cols-2 gap-3">
                <Button
                  variant="outline"
                  onClick={onClearAll}
                  className="border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white"
                >
                  <XCircle size={16} className="mr-2" />
                  Clear All
                </Button>

<Button
                  variant="outline"
                  onClick={exportToCSV}
                  disabled={answeredQuestions === 0}
                  className="border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white"
                >
                  <FileDown size={16} className="mr-2" />
                  Export CSV
                </Button>

<Dialog open={importDialog} onOpenChange={setImportDialog}>
                  <DialogTrigger asChild>
                    <Button
                      variant="outline"
                      className="border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white col-span-2"
                    >
                      <FileUp size={16} className="mr-2" />
                      Import Answers
                    </Button>
                  </DialogTrigger>
                  <DialogContent className="max-w-2xl max-h-[80vh] overflow-y-auto glass-card border-gray-800">
                    <DialogHeader>
                      <DialogTitle className="text-white">Import Answer Key</DialogTitle>
                    </DialogHeader>

<div className="space-y-4">
                      <div>
                        <Label htmlFor="file-upload" className="text-sm font-medium text-gray-300">
                          Upload File (CSV, TXT)
                        </Label>
                        <Input
                          id="file-upload"
                          type="file"
                          accept=".csv,.txt"
                          onChange={handleFileUpload}
                          className="mt-1 bg-black/40 border-gray-700"
                        />
                      </div>

<div className="text-sm text-gray-400">
                        <p className="font-medium mb-2 text-gray-300">Supported formats:</p>
                        <ul className="list-disc pl-5 space-y-1">
                          <li>
                            <strong className="text-gray-200">CSV:</strong> "1,A" or "Question 1,A" (one per line)
                          </li>
                          <li>
                            <strong className="text-gray-200">Plain text:</strong> "ABCDABCD..." or "A B C D A B C D..."
                          </li>
                          <li>
                            <strong className="text-gray-200">Single column:</strong> One answer per line (A, B, C,
                            D...)
                          </li>
                        </ul>
                      </div>

<div>
                        <Label htmlFor="import-text" className="text-sm font-medium text-gray-300">
                          Or paste text directly:
                        </Label>
                        <Textarea
                          id="import-text"
                          value={importText}
                          onChange={(e) => {
                            setImportText(e.target.value)
                            parseImportText(e.target.value)
                          }}
                          placeholder="Paste your answers here..."
                          className="mt-1 h-32 bg-black/40 border-gray-700 text-white"
                        />
                      </div>

{importError && (
                        <Alert variant="destructive" className="bg-red-900/20 border-red-900/50">
                          <AlertCircle className="h-4 w-4" />
                          <AlertDescription>{importError}</AlertDescription>
                        </Alert>
                      )}

{(validationResults.duplicates.length > 0 || validationResults.invalid.length > 0) && (
                        <div className="bg-amber-900/20 border border-amber-900/50 rounded-md p-3 text-sm">
                          <h4 className="font-medium text-amber-300 mb-2">Validation Warnings</h4>

{validationResults.duplicates.length > 0 && (
                            <div className="mb-2">
                              <p className="text-amber-200">Duplicate questions found:</p>
                              <div className="flex flex-wrap gap-1 mt-1">
                                {validationResults.duplicates.map((q) => (
                                  <Badge
                                    key={q}
                                    variant="outline"
                                    className="bg-amber-900/30 border-amber-500/30 text-amber-300"
                                  >
                                    Q{q}
                                  </Badge>
                                ))}
                              </div>
                            </div>
                          )}

{validationResults.invalid.length > 0 && (
                            <div>
                              <p className="text-amber-200">Invalid answers found:</p>
                              <div className="flex flex-wrap gap-1 mt-1">
                                {validationResults.invalid.map(({ question, value }) => (
                                  <Badge
                                    key={question}
                                    variant="outline"
                                    className="bg-amber-900/30 border-amber-500/30 text-amber-300"
                                  >
                                    Q{question}: {value}
                                  </Badge>
                                ))}
                              </div>
                            </div>
                          )}
                        </div>
                      )}

{Object.keys(importPreview).length > 0 && (
                        <div className="border border-gray-800 rounded-lg p-4 bg-black/20">
                          <div className="flex justify-between items-center mb-2">
                            <h4 className="font-medium text-white">Preview</h4>
                            <Badge variant="outline" className="bg-[#0070f3]/20 border-[#0070f3]/30 text-[#0070f3]">
                              {Object.keys(importPreview).length} answers found
                            </Badge>
                          </div>
                          <div className="grid grid-cols-8 gap-2 max-h-32 overflow-y-auto">
                            {Object.entries(importPreview)
                              .sort(([a], [b]) => Number.parseInt(a) - Number.parseInt(b))
                              .map(([questionNum, answer]) => (
                                <div key={questionNum} className="text-xs">
                                  <span className="font-medium text-gray-400">{questionNum}:</span>
                                  <span className="ml-1 bg-[#0070f3]/20 text-[#0070f3] px-1 rounded">{answer}</span>
                                </div>
                              ))}
                          </div>

{validationResults.missing.length > 0 && (
                            <div className="mt-3 text-xs text-gray-400">
                              <span className="text-gray-300">Missing answers: </span>
                              {validationResults.missing.length > 10
                                ? `${validationResults.missing.length} questions`
                                : validationResults.missing.map((q) => `Q${q}`).join(", ")}
                            </div>
                          )}
                        </div>
                      )}

<div className="flex justify-end space-x-2">
                        <Button
                          variant="outline"
                          onClick={clearImport}
                          className="border-gray-700 hover:border-gray-600"
                        >
                          Clear
                        </Button>
                        <Button
                          onClick={applyImportedAnswers}
                          disabled={Object.keys(importPreview).length === 0}
                          className="bg-[#0070f3] hover:bg-[#0060d3]"
                        >
                          Import {Object.keys(importPreview).length} Answers
                        </Button>
                      </div>
                    </div>
                  </DialogContent>
                </Dialog>

<Button
                  className="col-span-2 bg-[#0070f3] hover:bg-[#0060d3] blue-glow"
                  onClick={handlePrintAnswerKey}
                  disabled={answeredQuestions === 0}
                >
                  Print Answer Key
                </Button>
              </div>
            </TabsContent>

<TabsContent value="patterns" className="space-y-4">
              <div className="grid grid-cols-2 gap-3">
                {answerPatterns.map((pattern) => (
                  <Button
                    key={pattern.name}
                    variant="outline"
                    onClick={() => applyPattern(pattern)}
                    className="border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white justify-start"
                  >
                    <div className="mr-2 text-[#0070f3]">{pattern.icon}</div>
                    <div className="text-left">
                      <div className="font-medium text-white">{pattern.name}</div>
                      <div className="text-xs text-gray-400">{pattern.description}</div>
                    </div>
                  </Button>
                ))}
              </div>
            </TabsContent>

<TabsContent value="answers" className="space-y-4">
              <div className="max-h-96 overflow-y-auto space-y-2 pr-1">
                {Array.from({ length: config.numQuestions }, (_, i) => {
                  const questionNum = i + 1
                  return (
                    <div key={questionNum} className="flex items-center justify-between">
                      <span className="text-sm font-medium w-12 text-gray-300">Q{questionNum}:</span>
                      <Select
                        value={answers[questionNum] || ""}
                        onValueChange={(value) => onAnswerChange(questionNum, value)}
                      >
                        <SelectTrigger className="w-20 h-8 bg-black/40 border-gray-700">
                          <SelectValue placeholder="-" />
                        </SelectTrigger>
                        <SelectContent>
                          {optionLetters.slice(0, config.optionsPerQuestion).map((letter) => (
                            <SelectItem key={letter} value={letter}>
                              {letter}
                            </SelectItem>
                          ))}
                        </SelectContent>
                      </Select>
                    </div>
                  )
                })}
              </div>
            </TabsContent>
          </Tabs>
        </CardContent>
      </Card>

<div className="border border-gray-800 rounded-lg p-4 bg-black/40 overflow-auto max-h-[800px] glass-panel">
        <div ref={answerKeyRef} className="bg-white text-black">
          <AnswerKey config={config} answers={answers} />
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/answer-key.tsx"
"use client"

interface AnswerKeyProps {
  config: {
    title: string
    numQuestions: number
    optionsPerQuestion: number
    uniqueId: string
  }
  answers: Record<number, string>
}

export function AnswerKey({ config, answers }: AnswerKeyProps) {
  const answeredQuestions = Object.keys(answers).length

return (
    <div className="w-full bg-white p-8 print:p-4 print:shadow-none">
      <div className="border-2 border-black p-6 print:p-4">
        <div className="text-center border-b-2 border-black pb-4">
          <h1 className="text-2xl font-bold">ANSWER KEY</h1>
          <h2 className="text-lg font-medium mt-1">{config.title}</h2>
          <p className="text-sm mt-1">Sheet ID: {config.uniqueId}</p>
          <p className="text-sm text-gray-600">
            {answeredQuestions} of {config.numQuestions} questions answered
          </p>
        </div>

<div className="py-6">
          <div className="grid grid-cols-4 md:grid-cols-5 lg:grid-cols-6 gap-x-8 gap-y-2">
            {Array.from({ length: config.numQuestions }, (_, i) => {
              const questionNum = i + 1
              const answer = answers[questionNum]

return (
                <div key={questionNum} className="flex items-center justify-between">
                  <span className="font-medium text-sm mr-2">{questionNum}.</span>
                  <div
                    className={`w-8 h-6 rounded flex items-center justify-center text-sm font-bold ${
                      answer
                        ? "bg-green-100 text-green-800 border border-green-300"
                        : "bg-gray-100 text-gray-400 border border-gray-300"
                    }`}
                  >
                    {answer || "-"}
                  </div>
                </div>
              )
            })}
          </div>
        </div>

{answeredQuestions > 0 && (
          <div className="border-t-2 border-black pt-4">
            <div className="grid grid-cols-2 md:grid-cols-4 gap-4 text-sm">
              <div>
                <span className="font-bold">Total Questions:</span> {config.numQuestions}
              </div>
              <div>
                <span className="font-bold">Answered:</span> {answeredQuestions}
              </div>
              <div>
                <span className="font-bold">Options:</span> {config.optionsPerQuestion}
              </div>
              <div>
                <span className="font-bold">Generated:</span> {new Date().toLocaleDateString()}
              </div>
            </div>
          </div>
        )}
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/omr-grid-sheet.tsx"
"use client"

import { QRCodeSVG } from "qrcode.react"

interface OMRGridSheetProps {
  config: {
    title: string
    numQuestions: number
    optionsPerQuestion: number
    showRollNumber: boolean
    showName: boolean
    showInstructions: boolean
    uniqueId: string
  }
}

export function OMRGridSheet({ config }: OMRGridSheetProps) {
  const optionLetters = ["A", "B", "C", "D", "E"]
  const questionsPerRow = 10
  const rows = Math.ceil(config.numQuestions / questionsPerRow)

const qrData = JSON.stringify({
    id: config.uniqueId,
    title: config.title,
    questions: config.numQuestions,
    options: config.optionsPerQuestion,
    format: "grid",
  })

return (
    <div className="w-full bg-white p-8 print:p-4 print:shadow-none">
      <div className="border-2 border-black p-6 print:p-4">
        <div className="flex justify-between items-start border-b-2 border-black pb-4">
          <div className="flex-1">
            <h1 className="text-2xl font-bold">{config.title}</h1>
            <p className="text-sm mt-1">Sheet ID: {config.uniqueId} | Grid Format</p>
          </div>
          <div className="ml-4">
            <QRCodeSVG value={qrData} size={60} />
          </div>
        </div>

{(config.showName || config.showRollNumber) && (
          <div className="border-b-2 border-black py-4 grid grid-cols-1 md:grid-cols-2 gap-4">
            {config.showName && (
              <div className="flex items-center">
                <span className="font-bold mr-2 min-w-[80px]">Name:</span>
                <div className="border border-black flex-1 h-8"></div>
              </div>
            )}
            {config.showRollNumber && (
              <div className="flex items-center">
                <span className="font-bold mr-2 min-w-[80px]">Roll No:</span>
                <div className="border border-black flex-1 h-8"></div>
              </div>
            )}
          </div>
        )}

{config.showInstructions && (
          <div className="border-b-2 border-black py-4">
            <h2 className="font-bold mb-2">Instructions:</h2>
            <ul className="text-sm list-disc pl-5 space-y-1">
              <li>Use blue or black ball point pen only.</li>
              <li>Completely darken the bubble corresponding to your answer.</li>
              <li>Marking multiple bubbles for a question will invalidate the answer.</li>
              <li>Ensure your markings are dark and completely fill the bubble.</li>
              <li>Do not make any stray marks on the sheet.</li>
            </ul>
          </div>
        )}

<div className="py-4">
          <h2 className="font-bold mb-4 text-center">Answer Grid</h2>

{/* Grid Header */}
          <div className="grid grid-cols-11 gap-1 mb-2 text-xs font-bold">
            <div className="text-center">Q#</div>
            {optionLetters.slice(0, config.optionsPerQuestion).map((letter) => (
              <div key={letter} className="text-center">
                {letter}
              </div>
            ))}
          </div>

{/* Answer Grid */}
          {Array.from({ length: rows }, (_, rowIndex) => (
            <div key={rowIndex} className="mb-6">
              <div className="grid gap-2">
                {Array.from({ length: questionsPerRow }, (_, colIndex) => {
                  const questionNum = rowIndex * questionsPerRow + colIndex + 1
                  if (questionNum > config.numQuestions) return null

return (
                    <div key={questionNum} className="grid grid-cols-11 gap-1 items-center">
                      <div className="text-center font-medium text-sm">{questionNum}</div>
                      {optionLetters.slice(0, config.optionsPerQuestion).map((letter) => (
                        <div key={letter} className="flex justify-center">
                          <div className="w-6 h-6 rounded-full border-2 border-black flex items-center justify-center">
                            <div className="w-3 h-3 rounded-full"></div>
                          </div>
                        </div>
                      ))}
                    </div>
                  )
                })}
              </div>
            </div>
          ))}
        </div>

{/* Timing marks for scanning */}
        <div className="border-t-2 border-black pt-2">
          <div className="flex justify-between items-center text-xs">
            <div className="flex space-x-1">
              {Array.from({ length: 10 }, (_, i) => (
                <div key={i} className="w-2 h-2 bg-black rounded-full"></div>
              ))}
            </div>
            <span>Scan ID: {config.uniqueId}</span>
            <div className="flex space-x-1">
              {Array.from({ length: 10 }, (_, i) => (
                <div key={i} className="w-2 h-2 bg-black rounded-full"></div>
              ))}
            </div>
          </div>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/omr-sheet-generator.tsx"
"use client"

import { useState, useRef } from "react"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Card, CardContent } from "@/components/ui/card"
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"
import { Slider } from "@/components/ui/slider"
import { Switch } from "@/components/ui/switch"
import { OMRSheet } from "@/components/omr-sheet"
import { OMRGridSheet } from "@/components/omr-grid-sheet"
import { AnswerKeyGenerator } from "@/components/answer-key-generator"
import { AnswerKeyComparison } from "@/components/answer-key-comparison"
import { StudentResponseScanner } from "@/components/student-response-scanner"
import { AnalyticsDashboard } from "@/components/analytics-dashboard"
import { Settings, Eye, GitCompare, Scan, BarChart3 } from "lucide-react"

export function OMRSheetGenerator() {
  const [config, setConfig] = useState({
    title: "Examination OMR Sheet",
    numQuestions: 50,
    optionsPerQuestion: 4,
    showRollNumber: true,
    showName: true,
    showInstructions: true,
    uniqueId: generateUniqueId(),
    format: "standard" as "standard" | "grid",
  })

const [answers, setAnswers] = useState<Record<number, string>>({})
  const [studentResponses, setStudentResponses] = useState<
    Array<{
      id: string
      name: string
      rollNumber: string
      responses: Record<number, string>
      score: number
      percentage: number
      timestamp: Date
    }>
  >([])
  const [currentView, setCurrentView] = useState<"sheet" | "answerkey" | "comparison" | "scanner" | "analytics">(
    "sheet",
  )

const sheetRef = useRef<HTMLDivElement>(null)

const handlePrint = () => {
    const printContent = sheetRef.current
    if (!printContent) return

const printWindow = window.open("", "_blank")
    if (!printWindow) return

printWindow.document.write(`
    <!DOCTYPE html>
    <html>
      <head>
        <title>OMR Sheet</title>
        <style>
          body { margin: 0; padding: 20px; font-family: Inter, sans-serif; background: white; color: black; }
          @media print {
            body { margin: 0; padding: 0; }
            .no-print { display: none; }
          }
          .border-2 { border: 2px solid black; }
          .border { border: 1px solid black; }
          .border-b-2 { border-bottom: 2px solid black; }
          .p-6 { padding: 24px; }
          .p-4 { padding: 16px; }
          .py-4 { padding-top: 16px; padding-bottom: 16px; }
          .pb-4 { padding-bottom: 16px; }
          .mb-4 { margin-bottom: 16px; }
          .mb-2 { margin-bottom: 8px; }
          .mb-1 { margin-bottom: 4px; }
          .mr-2 { margin-right: 8px; }
          .mt-1 { margin-top: 4px; }
          .text-center { text-align: center; }
          .text-right { text-align: right; }
          .text-2xl { font-size: 24px; }
          .text-sm { font-size: 14px; }
          .font-bold { font-weight: bold; }
          .font-medium { font-weight: 500; }
          .flex { display: flex; }
          .items-center { align-items: center; }
          .grid { display: grid; }
          .grid-cols-1 { grid-template-columns: repeat(1, minmax(0, 1fr)); }
          .grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
          .grid-cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
          .gap-4 { gap: 16px; }
          .gap-x-8 { column-gap: 32px; }
          .gap-y-1 { row-gap: 4px; }
          .space-x-3 > * + * { margin-left: 12px; }
          .space-y-1 > * + * { margin-top: 4px; }
          .w-full { width: 100%; }
          .w-6 { width: 24px; }
          .w-7 { width: 28px; }
          .h-6 { height: 24px; }
          .h-8 { height: 32px; }
          .min-w-20 { min-width: 80px; }
          .flex-1 { flex: 1; }
          .rounded-full { border-radius: 50%; }
          .justify-center { justify-content: center; }
          .list-disc { list-style-type: disc; }
          .pl-5 { padding-left: 20px; }
          @media (min-width: 768px) {
            .md\\:grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
            .md\\:grid-cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
          }
          @media (min-width: 1024px) {
            .lg\\:grid-cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
          }
        </style>
      </head>
      <body>
        ${printContent.innerHTML}
      </body>
    </html>
  `)

printWindow.document.close()
    printWindow.focus()
    setTimeout(() => {
      printWindow.print()
      printWindow.close()
    }, 250)
  }

function generateUniqueId() {
    return Math.random().toString(36).substring(2, 10).toUpperCase()
  }

function regenerateId() {
    setConfig({ ...config, uniqueId: generateUniqueId() })
  }

const handleAnswerChange = (questionNum: number, answer: string) => {
    setAnswers((prev) => ({ ...prev, [questionNum]: answer }))
  }

const clearAllAnswers = () => {
    setAnswers({})
  }

const generateRandomAnswers = () => {
    const optionLetters = ["A", "B", "C", "D", "E"]
    const randomAnswers: Record<number, string> = {}
    for (let i = 1; i <= config.numQuestions; i++) {
      const randomIndex = Math.floor(Math.random() * config.optionsPerQuestion)
      randomAnswers[i] = optionLetters[randomIndex]
    }
    setAnswers(randomAnswers)
  }

const addStudentResponse = (response: {
    id: string
    name: string
    rollNumber: string
    responses: Record<number, string>
    score: number
    percentage: number
  }) => {
    setStudentResponses((prev) => [...prev, { ...response, timestamp: new Date() }])
  }

const navigationItems = [
    { id: "sheet", label: "OMR Sheet", icon: <Eye size={18} /> },
    { id: "answerkey", label: "Answer Key", icon: <Settings size={18} /> },
    { id: "comparison", label: "Compare", icon: <GitCompare size={18} /> },
    { id: "scanner", label: "Scanner", icon: <Scan size={18} /> },
    { id: "analytics", label: "Analytics", icon: <BarChart3 size={18} /> },
  ]

return (
    <div className="space-y-6">
      <div className="flex justify-center">
        <div className="flex bg-black/40 rounded-lg p-1 glass-panel overflow-x-auto">
          {navigationItems.map((item) => (
            <Button
              key={item.id}
              variant={currentView === item.id ? "default" : "ghost"}
              onClick={() => setCurrentView(item.id as any)}
              className="rounded-md gap-2 whitespace-nowrap"
            >
              {item.icon}
              {item.label}
            </Button>
          ))}
        </div>
      </div>

{currentView === "sheet" && (
        <div className="grid md:grid-cols-2 gap-8">
          <Card className="glass-card border-0">
            <CardContent className="pt-6">
              <div className="space-y-6">
                <div className="space-y-2">
                  <Label htmlFor="title" className="text-gray-300">
                    Sheet Title
                  </Label>
                  <Input
                    id="title"
                    value={config.title}
                    onChange={(e) => setConfig({ ...config, title: e.target.value })}
                    className="bg-black/40 border-gray-700 focus:border-blue-500"
                  />
                </div>

<div className="space-y-2">
                  <Label htmlFor="format" className="text-gray-300">
                    Sheet Format
                  </Label>
                  <Select
                    value={config.format}
                    onValueChange={(value) => setConfig({ ...config, format: value as "standard" | "grid" })}
                  >
                    <SelectTrigger id="format" className="bg-black/40 border-gray-700">
                      <SelectValue placeholder="Select format" />
                    </SelectTrigger>
                    <SelectContent>
                      <SelectItem value="standard">Standard Format</SelectItem>
                      <SelectItem value="grid">Grid Format</SelectItem>
                    </SelectContent>
                  </Select>
                </div>

<div className="space-y-2">
                  <Label className="text-gray-300">Number of Questions: {config.numQuestions}</Label>
                  <Slider
                    value={[config.numQuestions]}
                    min={10}
                    max={200}
                    step={5}
                    onValueChange={(value) => setConfig({ ...config, numQuestions: value[0] })}
                    className="py-2"
                  />
                </div>

<div className="space-y-2">
                  <Label htmlFor="options" className="text-gray-300">
                    Options per Question
                  </Label>
                  <Select
                    value={config.optionsPerQuestion.toString()}
                    onValueChange={(value) => setConfig({ ...config, optionsPerQuestion: Number.parseInt(value) })}
                  >
                    <SelectTrigger id="options" className="bg-black/40 border-gray-700">
                      <SelectValue placeholder="Select options" />
                    </SelectTrigger>
                    <SelectContent>
                      <SelectItem value="2">2 (A-B)</SelectItem>
                      <SelectItem value="3">3 (A-C)</SelectItem>
                      <SelectItem value="4">4 (A-D)</SelectItem>
                      <SelectItem value="5">5 (A-E)</SelectItem>
                    </SelectContent>
                  </Select>
                </div>

<div className="flex items-center justify-between">
                  <Label htmlFor="roll-number" className="text-gray-300">
                    Show Roll Number Field
                  </Label>
                  <Switch
                    id="roll-number"
                    checked={config.showRollNumber}
                    onCheckedChange={(checked) => setConfig({ ...config, showRollNumber: checked })}
                  />
                </div>

<div className="flex items-center justify-between">
                  <Label htmlFor="name" className="text-gray-300">
                    Show Name Field
                  </Label>
                  <Switch
                    id="name"
                    checked={config.showName}
                    onCheckedChange={(checked) => setConfig({ ...config, showName: checked })}
                  />
                </div>

<div className="flex items-center justify-between">
                  <Label htmlFor="instructions" className="text-gray-300">
                    Show Instructions
                  </Label>
                  <Switch
                    id="instructions"
                    checked={config.showInstructions}
                    onCheckedChange={(checked) => setConfig({ ...config, showInstructions: checked })}
                  />
                </div>

<div className="flex items-center justify-between">
                  <Label htmlFor="unique-id" className="text-gray-300">
                    Sheet ID: <span className="text-white">{config.uniqueId}</span>
                  </Label>
                  <Button
                    variant="outline"
                    size="sm"
                    onClick={regenerateId}
                    className="border-gray-700 hover:border-blue-500"
                  >
                    Regenerate ID
                  </Button>
                </div>

<Button className="w-full bg-[#0070f3] hover:bg-[#0060d3] blue-glow" onClick={handlePrint}>
                  Print OMR Sheet
                </Button>
              </div>
            </CardContent>
          </Card>

<div className="border border-gray-800 rounded-lg p-4 bg-black/40 overflow-auto max-h-[800px] glass-panel">
            <div ref={sheetRef} className="bg-white text-black">
              {config.format === "standard" ? <OMRSheet config={config} /> : <OMRGridSheet config={config} />}
            </div>
          </div>
        </div>
      )}

{currentView === "answerkey" && (
        <AnswerKeyGenerator
          config={config}
          answers={answers}
          onAnswerChange={handleAnswerChange}
          onClearAll={clearAllAnswers}
          onGenerateRandom={generateRandomAnswers}
        />
      )}

{currentView === "comparison" && (
        <AnswerKeyComparison config={config} primaryAnswers={answers} onAnswerChange={handleAnswerChange} />
      )}

{currentView === "scanner" && (
        <StudentResponseScanner
          config={config}
          answerKey={answers}
          onAddResponse={addStudentResponse}
          studentResponses={studentResponses}
        />
      )}

{currentView === "analytics" && (
        <AnalyticsDashboard config={config} answerKey={answers} studentResponses={studentResponses} />
      )}
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/omr-sheet.tsx"
"use client"

interface OMRSheetProps {
  config: {
    title: string
    numQuestions: number
    optionsPerQuestion: number
    showRollNumber: boolean
    showName: boolean
    showInstructions: boolean
    uniqueId: string
  }
}

export function OMRSheet({ config }: OMRSheetProps) {
  const optionLetters = ["A", "B", "C", "D", "E"]

<div className="py-4">
          <h2 className="font-bold mb-4 text-center">Answer Sheet</h2>
          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-x-8 gap-y-1">
            {Array.from({ length: config.numQuestions }, (_, i) => (
              <div key={i} className="flex items-center mb-1">
                <span className="font-medium mr-2 w-7 text-right">{i + 1}.</span>
                <div className="flex space-x-3">
                  {Array.from({ length: config.optionsPerQuestion }, (_, j) => (
                    <div key={j} className="flex items-center">
                      <div className="w-6 h-6 rounded-full border border-black flex items-center justify-center">
                        {optionLetters[j]}
                      </div>
                    </div>
                  ))}
                </div>
              </div>
            ))}
          </div>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/student-response-scanner.tsx"
"use client"

import type React from "react"

import { useState, useRef } from "react"
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Textarea } from "@/components/ui/textarea"
import { Badge } from "@/components/ui/badge"
import { Alert, AlertDescription } from "@/components/ui/alert"
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
import { Scan, UserPlus, Download, Camera, XCircle } from "lucide-react"

interface StudentResponse {
  id: string
  name: string
  rollNumber: string
  responses: Record<number, string>
  score: number
  percentage: number
  timestamp: Date
}

interface StudentResponseScannerProps {
  config: {
    title: string
    numQuestions: number
    optionsPerQuestion: number
    uniqueId: string
  }
  answerKey: Record<number, string>
  onAddResponse: (response: Omit<StudentResponse, "timestamp">) => void
  studentResponses: StudentResponse[]
}

export function StudentResponseScanner({
  config,
  answerKey,
  onAddResponse,
  studentResponses,
}: StudentResponseScannerProps) {
  const [studentName, setStudentName] = useState("")
  const [rollNumber, setRollNumber] = useState("")
  const [responseText, setResponseText] = useState("")
  const [parsedResponses, setParsedResponses] = useState<Record<number, string>>({})
  const [scanError, setScanError] = useState("")
  const fileInputRef = useRef<HTMLInputElement>(null)

const optionLetters = ["A", "B", "C", "D", "E"]

const parseResponseText = (text: string) => {
    setScanError("")
    setParsedResponses({})

if (!text.trim()) return

try {
      const lines = text.trim().split("\n")
      const parsed: Record<number, string> = {}
      const validOptions = optionLetters.slice(0, config.optionsPerQuestion)

const firstLine = lines[0].trim()

if (firstLine.includes(",") || firstLine.includes("\t")) {
        lines.forEach((line, index) => {
          const parts = line.split(/[,\t]/).map((p) => p.trim())

if (parts.length >= 2) {
            const questionNum = Number.parseInt(parts[0].replace(/\D/g, "")) || index + 1
            const answer = parts[1].toUpperCase()

if (questionNum <= config.numQuestions && validOptions.includes(answer)) {
              parsed[questionNum] = answer
            }
          } else if (parts.length === 1 && parts[0]) {
            const questionNum = index + 1
            const answer = parts[0].toUpperCase()

if (questionNum <= config.numQuestions && validOptions.includes(answer)) {
              parsed[questionNum] = answer
            }
          }
        })
      } else {
        const cleanText = text.replace(/\s+/g, "").toUpperCase()

if (cleanText.length <= config.numQuestions) {
          for (let i = 0; i < cleanText.length && i < config.numQuestions; i++) {
            const answer = cleanText[i]
            if (validOptions.includes(answer)) {
              parsed[i + 1] = answer
            }
          }
        } else {
          const answers = text
            .trim()
            .split(/\s+/)
            .map((a) => a.toUpperCase())
          answers.forEach((answer, index) => {
            const questionNum = index + 1
            if (questionNum <= config.numQuestions && validOptions.includes(answer)) {
              parsed[questionNum] = answer
            }
          })
        }
      }

if (Object.keys(parsed).length === 0) {
        setScanError("No valid responses found. Please check your format.")
      } else {
        setParsedResponses(parsed)
      }
    } catch (error) {
      setScanError("Error parsing responses. Please check the format.")
    }
  }

const calculateScore = (responses: Record<number, string>) => {
    let correct = 0
    const totalAnswered = Object.keys(responses).length

Object.entries(responses).forEach(([questionNum, answer]) => {
      if (answerKey[Number.parseInt(questionNum)] === answer) {
        correct++
      }
    })

return {
      score: correct,
      percentage: totalAnswered > 0 ? Math.round((correct / config.numQuestions) * 100) : 0,
    }
  }

const submitResponse = () => {
    if (!studentName.trim() || !rollNumber.trim() || Object.keys(parsedResponses).length === 0) {
      setScanError("Please fill in all required fields and scan responses.")
      return
    }

const { score, percentage } = calculateScore(parsedResponses)

onAddResponse({
      id: `${rollNumber}_${Date.now()}`,
      name: studentName.trim(),
      rollNumber: rollNumber.trim(),
      responses: parsedResponses,
      score,
      percentage,
    })

// Clear form
    setStudentName("")
    setRollNumber("")
    setResponseText("")
    setParsedResponses({})
    setScanError("")
  }

const handleFileUpload = (event: React.ChangeEvent<HTMLInputElement>) => {
    const file = event.target.files?.[0]
    if (!file) return

// Simulate OCR processing
    setTimeout(() => {
      const mockResponses = Array.from({ length: config.numQuestions }, (_, i) => {
        const randomIndex = Math.floor(Math.random() * config.optionsPerQuestion)
        return optionLetters[randomIndex]
      }).join("")

setResponseText(mockResponses)
      parseResponseText(mockResponses)
    }, 1000)
  }

const exportResults = () => {
    if (studentResponses.length === 0) return

let csvContent = "Name,Roll Number,Score,Percentage,Timestamp\n"

studentResponses.forEach((response) => {
      csvContent += `${response.name},${response.rollNumber},${response.score},${response.percentage}%,${response.timestamp.toLocaleString()}\n`
    })

const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" })
    const url = URL.createObjectURL(blob)
    const link = document.createElement("a")
    link.setAttribute("href", url)
    link.setAttribute("download", `student_results_${config.uniqueId}.csv`)
    link.style.visibility = "hidden"
    document.body.appendChild(link)
    link.click()
    document.body.removeChild(link)
  }

const getGradeDistribution = () => {
    const distribution = { A: 0, B: 0, C: 0, D: 0, F: 0 }

studentResponses.forEach((response) => {
      if (response.percentage >= 90) distribution.A++
      else if (response.percentage >= 80) distribution.B++
      else if (response.percentage >= 70) distribution.C++
      else if (response.percentage >= 60) distribution.D++
      else distribution.F++
    })

return distribution
  }

const gradeDistribution = getGradeDistribution()
  const averageScore =
    studentResponses.length > 0
      ? Math.round(studentResponses.reduce((sum, r) => sum + r.percentage, 0) / studentResponses.length)
      : 0

return (
    <div className="space-y-6">
      <div className="grid md:grid-cols-3 gap-6">
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white flex items-center gap-2">
              <Scan size={20} />
              Scan Student Response
            </CardTitle>
          </CardHeader>
          <CardContent className="space-y-4 pt-6">
            <div className="space-y-2">
              <Label htmlFor="student-name" className="text-gray-300">
                Student Name
              </Label>
              <Input
                id="student-name"
                value={studentName}
                onChange={(e) => setStudentName(e.target.value)}
                className="bg-black/40 border-gray-700"
                placeholder="Enter student name"
              />
            </div>

<div className="space-y-2">
              <Label htmlFor="roll-number" className="text-gray-300">
                Roll Number
              </Label>
              <Input
                id="roll-number"
                value={rollNumber}
                onChange={(e) => setRollNumber(e.target.value)}
                className="bg-black/40 border-gray-700"
                placeholder="Enter roll number"
              />
            </div>

<Tabs defaultValue="manual" className="w-full">
              <TabsList className="grid grid-cols-2 mb-4 bg-black/40">
                <TabsTrigger value="manual">Manual Entry</TabsTrigger>
                <TabsTrigger value="scan">Scan Image</TabsTrigger>
              </TabsList>

<TabsContent value="manual" className="space-y-4">
                <div className="space-y-2">
                  <Label htmlFor="responses" className="text-gray-300">
                    Student Responses
                  </Label>
                  <Textarea
                    id="responses"
                    value={responseText}
                    onChange={(e) => {
                      setResponseText(e.target.value)
                      parseResponseText(e.target.value)
                    }}
                    placeholder="Enter responses (e.g., ABCDABCD... or A,B,C,D...)"
                    className="h-32 bg-black/40 border-gray-700 text-white"
                  />
                </div>
              </TabsContent>

<TabsContent value="scan" className="space-y-4">
                <div className="space-y-2">
                  <Label className="text-gray-300">Upload OMR Sheet Image</Label>
                  <input
                    ref={fileInputRef}
                    type="file"
                    accept="image/*"
                    onChange={handleFileUpload}
                    className="hidden"
                  />
                  <Button
                    variant="outline"
                    onClick={() => fileInputRef.current?.click()}
                    className="w-full border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white"
                  >
                    <Camera size={16} className="mr-2" />
                    Upload Image for OCR
                  </Button>
                  <p className="text-xs text-gray-400">
                    Note: This is a demo. In production, this would use OCR to scan the OMR sheet.
                  </p>
                </div>
              </TabsContent>
            </Tabs>

{scanError && (
              <Alert variant="destructive" className="bg-red-900/20 border-red-900/50">
                <XCircle className="h-4 w-4" />
                <AlertDescription>{scanError}</AlertDescription>
              </Alert>
            )}

{Object.keys(parsedResponses).length > 0 && (
              <div className="bg-[#0070f3]/10 p-3 rounded-lg border border-[#0070f3]/20">
                <h4 className="font-medium text-white mb-2">
                  Scanned Responses ({Object.keys(parsedResponses).length} answers)
                </h4>
                <div className="grid grid-cols-8 gap-1 text-xs">
                  {Object.entries(parsedResponses)
                    .sort(([a], [b]) => Number.parseInt(a) - Number.parseInt(b))
                    .map(([questionNum, answer]) => (
                      <div key={questionNum} className="text-center">
                        <span className="text-gray-400">{questionNum}:</span>
                        <span className="ml-1 text-[#0070f3] font-medium">{answer}</span>
                      </div>
                    ))}
                </div>
                {Object.keys(answerKey).length > 0 && (
                  <div className="mt-2 pt-2 border-t border-[#0070f3]/20">
                    <div className="text-sm">
                      <span className="text-gray-300">Predicted Score: </span>
                      <span className="text-white font-medium">
                        {calculateScore(parsedResponses).score}/{config.numQuestions} (
                        {calculateScore(parsedResponses).percentage}%)
                      </span>
                    </div>
                  </div>
                )}
              </div>
            )}

<Button
              className="w-full bg-[#0070f3] hover:bg-[#0060d3]"
              onClick={submitResponse}
              disabled={!studentName.trim() || !rollNumber.trim() || Object.keys(parsedResponses).length === 0}
            >
              <UserPlus size={16} className="mr-2" />
              Add Student Response
            </Button>
          </CardContent>
        </Card>

<Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Class Statistics</CardTitle>
          </CardHeader>
          <CardContent className="space-y-4 pt-6">
            <div className="grid grid-cols-2 gap-4">
              <div className="bg-black/20 p-3 rounded-lg">
                <div className="text-2xl font-bold text-[#0070f3]">{studentResponses.length}</div>
                <div className="text-sm text-gray-300">Students Scanned</div>
              </div>
              <div className="bg-black/20 p-3 rounded-lg">
                <div className="text-2xl font-bold text-green-400">{averageScore}%</div>
                <div className="text-sm text-gray-300">Average Score</div>
              </div>
            </div>

<div className="space-y-2">
              <h4 className="font-medium text-white">Grade Distribution</h4>
              {Object.entries(gradeDistribution).map(([grade, count]) => (
                <div key={grade} className="flex justify-between items-center">
                  <span className="text-gray-300">Grade {grade}:</span>
                  <Badge variant="outline" className="border-gray-700 text-gray-300">
                    {count}
                  </Badge>
                </div>
              ))}
            </div>

<Button
              variant="outline"
              onClick={exportResults}
              disabled={studentResponses.length === 0}
              className="w-full border-gray-700 hover:border-[#0070f3] text-gray-300 hover:text-white"
            >
              <Download size={16} className="mr-2" />
              Export Results
            </Button>
          </CardContent>
        </Card>

<Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Recent Submissions</CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <div className="max-h-[400px] overflow-y-auto space-y-3">
              {studentResponses.length === 0 ? (
                <p className="text-gray-400 text-center py-8">No submissions yet</p>
              ) : (
                studentResponses
                  .slice()
                  .reverse()
                  .slice(0, 10)
                  .map((response) => (
                    <div key={response.id} className="bg-black/20 p-3 rounded-lg">
                      <div className="flex justify-between items-start mb-2">
                        <div>
                          <div className="font-medium text-white">{response.name}</div>
                          <div className="text-sm text-gray-400">Roll: {response.rollNumber}</div>
                        </div>
                        <Badge
                          className={
                            response.percentage >= 80
                              ? "bg-green-900/30 text-green-400 border-green-900/50"
                              : response.percentage >= 60
                                ? "bg-yellow-900/30 text-yellow-400 border-yellow-900/50"
                                : "bg-red-900/30 text-red-400 border-red-900/50"
                          }
                        >
                          {response.percentage}%
                        </Badge>
                      </div>
                      <div className="text-xs text-gray-400">
                        {response.score}/{config.numQuestions} correct • {response.timestamp.toLocaleString()}
                      </div>
                    </div>
                  ))
              )}
            </div>
          </CardContent>
        </Card>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/theme-provider.tsx"
'use client'

import * as React from 'react'
import {
  ThemeProvider as NextThemesProvider,
  type ThemeProviderProps,
} from 'next-themes'

export function ThemeProvider({ children, ...props }: ThemeProviderProps) {
  return <NextThemesProvider {...props}>{children}</NextThemesProvider>
}
[V0_FILE]typescriptreact:file="components/ui/accordion.tsx"
"use client"

import * as React from "react"
import * as AccordionPrimitive from "@radix-ui/react-accordion"
import { ChevronDown } from "lucide-react"

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

const Accordion = AccordionPrimitive.Root

const AccordionItem = React.forwardRef<
  React.ElementRef<typeof AccordionPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item>
>(({ className, ...props }, ref) => (
  <AccordionPrimitive.Item
    ref={ref}
    className={cn("border-b", className)}
    {...props}
  />
))
AccordionItem.displayName = "AccordionItem"

const AccordionTrigger = React.forwardRef<
  React.ElementRef<typeof AccordionPrimitive.Trigger>,
  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>
>(({ className, children, ...props }, ref) => (
  <AccordionPrimitive.Header className="flex">
    <AccordionPrimitive.Trigger
      ref={ref}
      className={cn(
        "flex flex-1 items-center justify-between py-4 font-medium transition-all hover:underline [&[data-state=open]>svg]:rotate-180",
        className
      )}
      {...props}
    >
      {children}
      <ChevronDown className="h-4 w-4 shrink-0 transition-transform duration-200" />
    </AccordionPrimitive.Trigger>
  </AccordionPrimitive.Header>
))
AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName

const AccordionContent = React.forwardRef<
  React.ElementRef<typeof AccordionPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content>
>(({ className, children, ...props }, ref) => (
  <AccordionPrimitive.Content
    ref={ref}
    className="overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down"
    {...props}
  >
    <div className={cn("pb-4 pt-0", className)}>{children}</div>
  </AccordionPrimitive.Content>
))

AccordionContent.displayName = AccordionPrimitive.Content.displayName

export { Accordion, AccordionItem, AccordionTrigger, AccordionContent }
[V0_FILE]typescriptreact:file="components/ui/alert-dialog.tsx"
"use client"

import * as React from "react"
import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog"

import { cn } from "@/lib/utils"
import { buttonVariants } from "@/components/ui/button"

const AlertDialog = AlertDialogPrimitive.Root

const AlertDialogTrigger = AlertDialogPrimitive.Trigger

const AlertDialogPortal = AlertDialogPrimitive.Portal

const AlertDialogOverlay = React.forwardRef<
  React.ElementRef<typeof AlertDialogPrimitive.Overlay>,
  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Overlay>
>(({ className, ...props }, ref) => (
  <AlertDialogPrimitive.Overlay
    className={cn(
      "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
      className
    )}
    {...props}
    ref={ref}
  />
))
AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName

const AlertDialogContent = React.forwardRef<
  React.ElementRef<typeof AlertDialogPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Content>
>(({ className, ...props }, ref) => (
  <AlertDialogPortal>
    <AlertDialogOverlay />
    <AlertDialogPrimitive.Content
      ref={ref}
      className={cn(
        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
        className
      )}
      {...props}
    />
  </AlertDialogPortal>
))
AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName

const AlertDialogHeader = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn(
      "flex flex-col space-y-2 text-center sm:text-left",
      className
    )}
    {...props}
  />
)
AlertDialogHeader.displayName = "AlertDialogHeader"

const AlertDialogFooter = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn(
      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
      className
    )}
    {...props}
  />
)
AlertDialogFooter.displayName = "AlertDialogFooter"

const AlertDialogTitle = React.forwardRef<
  React.ElementRef<typeof AlertDialogPrimitive.Title>,
  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Title>
>(({ className, ...props }, ref) => (
  <AlertDialogPrimitive.Title
    ref={ref}
    className={cn("text-lg font-semibold", className)}
    {...props}
  />
))
AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName

const AlertDialogDescription = React.forwardRef<
  React.ElementRef<typeof AlertDialogPrimitive.Description>,
  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Description>
>(({ className, ...props }, ref) => (
  <AlertDialogPrimitive.Description
    ref={ref}
    className={cn("text-sm text-muted-foreground", className)}
    {...props}
  />
))
AlertDialogDescription.displayName =
  AlertDialogPrimitive.Description.displayName

const AlertDialogAction = React.forwardRef<
  React.ElementRef<typeof AlertDialogPrimitive.Action>,
  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Action>
>(({ className, ...props }, ref) => (
  <AlertDialogPrimitive.Action
    ref={ref}
    className={cn(buttonVariants(), className)}
    {...props}
  />
))
AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName

const AlertDialogCancel = React.forwardRef<
  React.ElementRef<typeof AlertDialogPrimitive.Cancel>,
  React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Cancel>
>(({ className, ...props }, ref) => (
  <AlertDialogPrimitive.Cancel
    ref={ref}
    className={cn(
      buttonVariants({ variant: "outline" }),
      "mt-2 sm:mt-0",
      className
    )}
    {...props}
  />
))
AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName

export {
  AlertDialog,
  AlertDialogPortal,
  AlertDialogOverlay,
  AlertDialogTrigger,
  AlertDialogContent,
  AlertDialogHeader,
  AlertDialogFooter,
  AlertDialogTitle,
  AlertDialogDescription,
  AlertDialogAction,
  AlertDialogCancel,
}
[V0_FILE]typescriptreact:file="components/ui/alert.tsx"
import * as React from "react"
import { cva, type VariantProps } from "class-variance-authority"

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

const alertVariants = cva(
  "relative w-full rounded-lg border p-4 [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground",
  {
    variants: {
      variant: {
        default: "bg-background text-foreground",
        destructive: "border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
      },
    },
    defaultVariants: {
      variant: "default",
    },
  },
)

const Alert = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
>(({ className, variant, ...props }, ref) => (
  <div ref={ref} role="alert" className={cn(alertVariants({ variant }), className)} {...props} />
))
Alert.displayName = "Alert"

const AlertTitle = React.forwardRef<HTMLParagraphElement, React.HTMLAttributes<HTMLHeadingElement>>(
  ({ className, ...props }, ref) => (
    <h5 ref={ref} className={cn("mb-1 font-medium leading-none tracking-tight", className)} {...props} />
  ),
)
AlertTitle.displayName = "AlertTitle"

const AlertDescription = React.forwardRef<HTMLParagraphElement, React.HTMLAttributes<HTMLParagraphElement>>(
  ({ className, ...props }, ref) => (
    <div ref={ref} className={cn("text-sm [&_p]:leading-relaxed", className)} {...props} />
  ),
)
AlertDescription.displayName = "AlertDescription"

export { Alert, AlertTitle, AlertDescription }
[V0_FILE]typescriptreact:file="components/ui/aspect-ratio.tsx"
"use client"

import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio"

const AspectRatio = AspectRatioPrimitive.Root

export { AspectRatio }
[V0_FILE]typescriptreact:file="components/ui/avatar.tsx"
"use client"

import * as React from "react"
import * as AvatarPrimitive from "@radix-ui/react-avatar"

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

const Avatar = React.forwardRef<
  React.ElementRef<typeof AvatarPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>
>(({ className, ...props }, ref) => (
  <AvatarPrimitive.Root
    ref={ref}
    className={cn(
      "relative flex h-10 w-10 shrink-0 overflow-hidden rounded-full",
      className
    )}
    {...props}
  />
))
Avatar.displayName = AvatarPrimitive.Root.displayName

const AvatarImage = React.forwardRef<
  React.ElementRef<typeof AvatarPrimitive.Image>,
  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image>
>(({ className, ...props }, ref) => (
  <AvatarPrimitive.Image
    ref={ref}
    className={cn("aspect-square h-full w-full", className)}
    {...props}
  />
))
AvatarImage.displayName = AvatarPrimitive.Image.displayName

const AvatarFallback = React.forwardRef<
  React.ElementRef<typeof AvatarPrimitive.Fallback>,
  React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>
>(({ className, ...props }, ref) => (
  <AvatarPrimitive.Fallback
    ref={ref}
    className={cn(
      "flex h-full w-full items-center justify-center rounded-full bg-muted",
      className
    )}
    {...props}
  />
))
AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName

export { Avatar, AvatarImage, AvatarFallback }
[V0_FILE]typescriptreact:file="components/ui/badge.tsx"
import type * as React from "react"
import { cva, type VariantProps } from "class-variance-authority"

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

const badgeVariants = cva(
  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
  {
    variants: {
      variant: {
        default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
        secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
        destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
        outline: "text-foreground",
      },
    },
    defaultVariants: {
      variant: "default",
    },
  },
)

export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {}

function Badge({ className, variant, ...props }: BadgeProps) {
  return <div className={cn(badgeVariants({ variant }), className)} {...props} />
}

export { Badge, badgeVariants }
[V0_FILE]typescriptreact:file="components/ui/breadcrumb.tsx"
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { ChevronRight, MoreHorizontal } from "lucide-react"

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

const Breadcrumb = React.forwardRef<
  HTMLElement,
  React.ComponentPropsWithoutRef<"nav"> & {
    separator?: React.ReactNode
  }
>(({ ...props }, ref) => <nav ref={ref} aria-label="breadcrumb" {...props} />)
Breadcrumb.displayName = "Breadcrumb"

const BreadcrumbList = React.forwardRef<
  HTMLOListElement,
  React.ComponentPropsWithoutRef<"ol">
>(({ className, ...props }, ref) => (
  <ol
    ref={ref}
    className={cn(
      "flex flex-wrap items-center gap-1.5 break-words text-sm text-muted-foreground sm:gap-2.5",
      className
    )}
    {...props}
  />
))
BreadcrumbList.displayName = "BreadcrumbList"

const BreadcrumbItem = React.forwardRef<
  HTMLLIElement,
  React.ComponentPropsWithoutRef<"li">
>(({ className, ...props }, ref) => (
  <li
    ref={ref}
    className={cn("inline-flex items-center gap-1.5", className)}
    {...props}
  />
))
BreadcrumbItem.displayName = "BreadcrumbItem"

const BreadcrumbLink = React.forwardRef<
  HTMLAnchorElement,
  React.ComponentPropsWithoutRef<"a"> & {
    asChild?: boolean
  }
>(({ asChild, className, ...props }, ref) => {
  const Comp = asChild ? Slot : "a"

return (
    <Comp
      ref={ref}
      className={cn("transition-colors hover:text-foreground", className)}
      {...props}
    />
  )
})
BreadcrumbLink.displayName = "BreadcrumbLink"

const BreadcrumbPage = React.forwardRef<
  HTMLSpanElement,
  React.ComponentPropsWithoutRef<"span">
>(({ className, ...props }, ref) => (
  <span
    ref={ref}
    role="link"
    aria-disabled="true"
    aria-current="page"
    className={cn("font-normal text-foreground", className)}
    {...props}
  />
))
BreadcrumbPage.displayName = "BreadcrumbPage"

const BreadcrumbSeparator = ({
  children,
  className,
  ...props
}: React.ComponentProps<"li">) => (
  <li
    role="presentation"
    aria-hidden="true"
    className={cn("[&>svg]:w-3.5 [&>svg]:h-3.5", className)}
    {...props}
  >
    {children ?? <ChevronRight />}
  </li>
)
BreadcrumbSeparator.displayName = "BreadcrumbSeparator"

const BreadcrumbEllipsis = ({
  className,
  ...props
}: React.ComponentProps<"span">) => (
  <span
    role="presentation"
    aria-hidden="true"
    className={cn("flex h-9 w-9 items-center justify-center", className)}
    {...props}
  >
    <MoreHorizontal className="h-4 w-4" />
    <span className="sr-only">More</span>
  </span>
)
BreadcrumbEllipsis.displayName = "BreadcrumbElipssis"

export {
  Breadcrumb,
  BreadcrumbList,
  BreadcrumbItem,
  BreadcrumbLink,
  BreadcrumbPage,
  BreadcrumbSeparator,
  BreadcrumbEllipsis,
}
[V0_FILE]typescriptreact:file="components/ui/button.tsx"
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { cva, type VariantProps } from "class-variance-authority"

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

const buttonVariants = cva(
  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
  {
    variants: {
      variant: {
        default: "bg-primary text-primary-foreground hover:bg-primary/90",
        destructive:
          "bg-destructive text-destructive-foreground hover:bg-destructive/90",
        outline:
          "border border-input bg-background hover:bg-accent hover:text-accent-foreground",
        secondary:
          "bg-secondary text-secondary-foreground hover:bg-secondary/80",
        ghost: "hover:bg-accent hover:text-accent-foreground",
        link: "text-primary underline-offset-4 hover:underline",
      },
      size: {
        default: "h-10 px-4 py-2",
        sm: "h-9 rounded-md px-3",
        lg: "h-11 rounded-md px-8",
        icon: "h-10 w-10",
      },
    },
    defaultVariants: {
      variant: "default",
      size: "default",
    },
  }
)

export interface ButtonProps
  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
    VariantProps<typeof buttonVariants> {
  asChild?: boolean
}

const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
  ({ className, variant, size, asChild = false, ...props }, ref) => {
    const Comp = asChild ? Slot : "button"
    return (
      <Comp
        className={cn(buttonVariants({ variant, size, className }))}
        ref={ref}
        {...props}
      />
    )
  }
)
Button.displayName = "Button"

export { Button, buttonVariants }
[V0_FILE]typescriptreact:file="components/ui/calendar.tsx"
"use client"

import * as React from "react"
import { ChevronLeft, ChevronRight } from "lucide-react"
import { DayPicker } from "react-day-picker"

import { cn } from "@/lib/utils"
import { buttonVariants } from "@/components/ui/button"

export type CalendarProps = React.ComponentProps<typeof DayPicker>

function Calendar({
  className,
  classNames,
  showOutsideDays = true,
  ...props
}: CalendarProps) {
  return (
    <DayPicker
      showOutsideDays={showOutsideDays}
      className={cn("p-3", className)}
      classNames={{
        months: "flex flex-col sm:flex-row space-y-4 sm:space-x-4 sm:space-y-0",
        month: "space-y-4",
        caption: "flex justify-center pt-1 relative items-center",
        caption_label: "text-sm font-medium",
        nav: "space-x-1 flex items-center",
        nav_button: cn(
          buttonVariants({ variant: "outline" }),
          "h-7 w-7 bg-transparent p-0 opacity-50 hover:opacity-100"
        ),
        nav_button_previous: "absolute left-1",
        nav_button_next: "absolute right-1",
        table: "w-full border-collapse space-y-1",
        head_row: "flex",
        head_cell:
          "text-muted-foreground rounded-md w-9 font-normal text-[0.8rem]",
        row: "flex w-full mt-2",
        cell: "h-9 w-9 text-center text-sm p-0 relative [&:has([aria-selected].day-range-end)]:rounded-r-md [&:has([aria-selected].day-outside)]:bg-accent/50 [&:has([aria-selected])]:bg-accent first:[&:has([aria-selected])]:rounded-l-md last:[&:has([aria-selected])]:rounded-r-md focus-within:relative focus-within:z-20",
        day: cn(
          buttonVariants({ variant: "ghost" }),
          "h-9 w-9 p-0 font-normal aria-selected:opacity-100"
        ),
        day_range_end: "day-range-end",
        day_selected:
          "bg-primary text-primary-foreground hover:bg-primary hover:text-primary-foreground focus:bg-primary focus:text-primary-foreground",
        day_today: "bg-accent text-accent-foreground",
        day_outside:
          "day-outside text-muted-foreground aria-selected:bg-accent/50 aria-selected:text-muted-foreground",
        day_disabled: "text-muted-foreground opacity-50",
        day_range_middle:
          "aria-selected:bg-accent aria-selected:text-accent-foreground",
        day_hidden: "invisible",
        ...classNames,
      }}
      components={{
        IconLeft: ({ ...props }) => <ChevronLeft className="h-4 w-4" />,
        IconRight: ({ ...props }) => <ChevronRight className="h-4 w-4" />,
      }}
      {...props}
    />
  )
}
Calendar.displayName = "Calendar"

export { Calendar }
[V0_FILE]typescriptreact:file="components/ui/card.tsx"
import * as React from "react"

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

const Card = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn(
      "rounded-lg border bg-card text-card-foreground shadow-sm",
      className
    )}
    {...props}
  />
))
Card.displayName = "Card"

const CardHeader = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn("flex flex-col space-y-1.5 p-6", className)}
    {...props}
  />
))
CardHeader.displayName = "CardHeader"

const CardTitle = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn(
      "text-2xl font-semibold leading-none tracking-tight",
      className
    )}
    {...props}
  />
))
CardTitle.displayName = "CardTitle"

const CardDescription = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn("text-sm text-muted-foreground", className)}
    {...props}
  />
))
CardDescription.displayName = "CardDescription"

const CardContent = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
))
CardContent.displayName = "CardContent"

const CardFooter = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    className={cn("flex items-center p-6 pt-0", className)}
    {...props}
  />
))
CardFooter.displayName = "CardFooter"

export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }
[V0_FILE]typescriptreact:file="components/ui/carousel.tsx"
"use client"

import * as React from "react"
import useEmblaCarousel, {
  type UseEmblaCarouselType,
} from "embla-carousel-react"
import { ArrowLeft, ArrowRight } from "lucide-react"

import { cn } from "@/lib/utils"
import { Button } from "@/components/ui/button"

type CarouselApi = UseEmblaCarouselType[1]
type UseCarouselParameters = Parameters<typeof useEmblaCarousel>
type CarouselOptions = UseCarouselParameters[0]
type CarouselPlugin = UseCarouselParameters[1]

type CarouselProps = {
  opts?: CarouselOptions
  plugins?: CarouselPlugin
  orientation?: "horizontal" | "vertical"
  setApi?: (api: CarouselApi) => void
}

type CarouselContextProps = {
  carouselRef: ReturnType<typeof useEmblaCarousel>[0]
  api: ReturnType<typeof useEmblaCarousel>[1]
  scrollPrev: () => void
  scrollNext: () => void
  canScrollPrev: boolean
  canScrollNext: boolean
} & CarouselProps

const CarouselContext = React.createContext<CarouselContextProps | null>(null)

function useCarousel() {
  const context = React.useContext(CarouselContext)

if (!context) {
    throw new Error("useCarousel must be used within a <Carousel />")
  }

return context
}

const Carousel = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement> & CarouselProps
>(
  (
    {
      orientation = "horizontal",
      opts,
      setApi,
      plugins,
      className,
      children,
      ...props
    },
    ref
  ) => {
    const [carouselRef, api] = useEmblaCarousel(
      {
        ...opts,
        axis: orientation === "horizontal" ? "x" : "y",
      },
      plugins
    )
    const [canScrollPrev, setCanScrollPrev] = React.useState(false)
    const [canScrollNext, setCanScrollNext] = React.useState(false)

const onSelect = React.useCallback((api: CarouselApi) => {
      if (!api) {
        return
      }

setCanScrollPrev(api.canScrollPrev())
      setCanScrollNext(api.canScrollNext())
    }, [])

const scrollPrev = React.useCallback(() => {
      api?.scrollPrev()
    }, [api])

const scrollNext = React.useCallback(() => {
      api?.scrollNext()
    }, [api])

const handleKeyDown = React.useCallback(
      (event: React.KeyboardEvent<HTMLDivElement>) => {
        if (event.key === "ArrowLeft") {
          event.preventDefault()
          scrollPrev()
        } else if (event.key === "ArrowRight") {
          event.preventDefault()
          scrollNext()
        }
      },
      [scrollPrev, scrollNext]
    )

React.useEffect(() => {
      if (!api || !setApi) {
        return
      }

setApi(api)
    }, [api, setApi])

React.useEffect(() => {
      if (!api) {
        return
      }

onSelect(api)
      api.on("reInit", onSelect)
      api.on("select", onSelect)

return () => {
        api?.off("select", onSelect)
      }
    }, [api, onSelect])

return (
      <CarouselContext.Provider
        value={{
          carouselRef,
          api: api,
          opts,
          orientation:
            orientation || (opts?.axis === "y" ? "vertical" : "horizontal"),
          scrollPrev,
          scrollNext,
          canScrollPrev,
          canScrollNext,
        }}
      >
        <div
          ref={ref}
          onKeyDownCapture={handleKeyDown}
          className={cn("relative", className)}
          role="region"
          aria-roledescription="carousel"
          {...props}
        >
          {children}
        </div>
      </CarouselContext.Provider>
    )
  }
)
Carousel.displayName = "Carousel"

const CarouselContent = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => {
  const { carouselRef, orientation } = useCarousel()

return (
    <div ref={carouselRef} className="overflow-hidden">
      <div
        ref={ref}
        className={cn(
          "flex",
          orientation === "horizontal" ? "-ml-4" : "-mt-4 flex-col",
          className
        )}
        {...props}
      />
    </div>
  )
})
CarouselContent.displayName = "CarouselContent"

const CarouselItem = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => {
  const { orientation } = useCarousel()

return (
    <div
      ref={ref}
      role="group"
      aria-roledescription="slide"
      className={cn(
        "min-w-0 shrink-0 grow-0 basis-full",
        orientation === "horizontal" ? "pl-4" : "pt-4",
        className
      )}
      {...props}
    />
  )
})
CarouselItem.displayName = "CarouselItem"

const CarouselPrevious = React.forwardRef<
  HTMLButtonElement,
  React.ComponentProps<typeof Button>
>(({ className, variant = "outline", size = "icon", ...props }, ref) => {
  const { orientation, scrollPrev, canScrollPrev } = useCarousel()

return (
    <Button
      ref={ref}
      variant={variant}
      size={size}
      className={cn(
        "absolute  h-8 w-8 rounded-full",
        orientation === "horizontal"
          ? "-left-12 top-1/2 -translate-y-1/2"
          : "-top-12 left-1/2 -translate-x-1/2 rotate-90",
        className
      )}
      disabled={!canScrollPrev}
      onClick={scrollPrev}
      {...props}
    >
      <ArrowLeft className="h-4 w-4" />
      <span className="sr-only">Previous slide</span>
    </Button>
  )
})
CarouselPrevious.displayName = "CarouselPrevious"

const CarouselNext = React.forwardRef<
  HTMLButtonElement,
  React.ComponentProps<typeof Button>
>(({ className, variant = "outline", size = "icon", ...props }, ref) => {
  const { orientation, scrollNext, canScrollNext } = useCarousel()

return (
    <Button
      ref={ref}
      variant={variant}
      size={size}
      className={cn(
        "absolute h-8 w-8 rounded-full",
        orientation === "horizontal"
          ? "-right-12 top-1/2 -translate-y-1/2"
          : "-bottom-12 left-1/2 -translate-x-1/2 rotate-90",
        className
      )}
      disabled={!canScrollNext}
      onClick={scrollNext}
      {...props}
    >
      <ArrowRight className="h-4 w-4" />
      <span className="sr-only">Next slide</span>
    </Button>
  )
})
CarouselNext.displayName = "CarouselNext"

export {
  type CarouselApi,
  Carousel,
  CarouselContent,
  CarouselItem,
  CarouselPrevious,
  CarouselNext,
}
[V0_FILE]typescriptreact:file="components/ui/chart.tsx"
"use client"

import * as React from "react"
import * as RechartsPrimitive from "recharts"

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

// Format: { THEME_NAME: CSS_SELECTOR }
const THEMES = { light: "", dark: ".dark" } as const

export type ChartConfig = {
  [k in string]: {
    label?: React.ReactNode
    icon?: React.ComponentType
  } & (
    | { color?: string; theme?: never }
    | { color?: never; theme: Record<keyof typeof THEMES, string> }
  )
}

type ChartContextProps = {
  config: ChartConfig
}

const ChartContext = React.createContext<ChartContextProps | null>(null)

function useChart() {
  const context = React.useContext(ChartContext)

if (!context) {
    throw new Error("useChart must be used within a <ChartContainer />")
  }

return context
}

const ChartContainer = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div"> & {
    config: ChartConfig
    children: React.ComponentProps<
      typeof RechartsPrimitive.ResponsiveContainer
    >["children"]
  }
>(({ id, className, children, config, ...props }, ref) => {
  const uniqueId = React.useId()
  const chartId = `chart-${id || uniqueId.replace(/:/g, "")}`

return (
    <ChartContext.Provider value={{ config }}>
      <div
        data-chart={chartId}
        ref={ref}
        className={cn(
          "flex aspect-video justify-center text-xs [&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground [&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50 [&_.recharts-curve.recharts-tooltip-cursor]:stroke-border [&_.recharts-dot[stroke='#fff']]:stroke-transparent [&_.recharts-layer]:outline-none [&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border [&_.recharts-radial-bar-background-sector]:fill-muted [&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted [&_.recharts-reference-line_[stroke='#ccc']]:stroke-border [&_.recharts-sector[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none",
          className
        )}
        {...props}
      >
        <ChartStyle id={chartId} config={config} />
        <RechartsPrimitive.ResponsiveContainer>
          {children}
        </RechartsPrimitive.ResponsiveContainer>
      </div>
    </ChartContext.Provider>
  )
})
ChartContainer.displayName = "Chart"

const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
  const colorConfig = Object.entries(config).filter(
    ([_, config]) => config.theme || config.color
  )

if (!colorConfig.length) {
    return null
  }

return (
    <style
      dangerouslySetInnerHTML={{
        __html: Object.entries(THEMES)
          .map(
            ([theme, prefix]) => `
${prefix} [data-chart=${id}] {
${colorConfig
  .map(([key, itemConfig]) => {
    const color =
      itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ||
      itemConfig.color
    return color ? `  --color-${key}: ${color};` : null
  })
  .join("\n")}
}
`
          )
          .join("\n"),
      }}
    />
  )
}

const ChartTooltip = RechartsPrimitive.Tooltip

const ChartTooltipContent = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<typeof RechartsPrimitive.Tooltip> &
    React.ComponentProps<"div"> & {
      hideLabel?: boolean
      hideIndicator?: boolean
      indicator?: "line" | "dot" | "dashed"
      nameKey?: string
      labelKey?: string
    }
>(
  (
    {
      active,
      payload,
      className,
      indicator = "dot",
      hideLabel = false,
      hideIndicator = false,
      label,
      labelFormatter,
      labelClassName,
      formatter,
      color,
      nameKey,
      labelKey,
    },
    ref
  ) => {
    const { config } = useChart()

const tooltipLabel = React.useMemo(() => {
      if (hideLabel || !payload?.length) {
        return null
      }

const [item] = payload
      const key = `${labelKey || item.dataKey || item.name || "value"}`
      const itemConfig = getPayloadConfigFromPayload(config, item, key)
      const value =
        !labelKey && typeof label === "string"
          ? config[label as keyof typeof config]?.label || label
          : itemConfig?.label

if (labelFormatter) {
        return (
          <div className={cn("font-medium", labelClassName)}>
            {labelFormatter(value, payload)}
          </div>
        )
      }

if (!value) {
        return null
      }

return <div className={cn("font-medium", labelClassName)}>{value}</div>
    }, [
      label,
      labelFormatter,
      payload,
      hideLabel,
      labelClassName,
      config,
      labelKey,
    ])

if (!active || !payload?.length) {
      return null
    }

const nestLabel = payload.length === 1 && indicator !== "dot"

return (
      <div
        ref={ref}
        className={cn(
          "grid min-w-[8rem] items-start gap-1.5 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-xs shadow-xl",
          className
        )}
      >
        {!nestLabel ? tooltipLabel : null}
        <div className="grid gap-1.5">
          {payload.map((item, index) => {
            const key = `${nameKey || item.name || item.dataKey || "value"}`
            const itemConfig = getPayloadConfigFromPayload(config, item, key)
            const indicatorColor = color || item.payload.fill || item.color

return (
              <div
                key={item.dataKey}
                className={cn(
                  "flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground",
                  indicator === "dot" && "items-center"
                )}
              >
                {formatter && item?.value !== undefined && item.name ? (
                  formatter(item.value, item.name, item, index, item.payload)
                ) : (
                  <>
                    {itemConfig?.icon ? (
                      <itemConfig.icon />
                    ) : (
                      !hideIndicator && (
                        <div
                          className={cn(
                            "shrink-0 rounded-[2px] border-[--color-border] bg-[--color-bg]",
                            {
                              "h-2.5 w-2.5": indicator === "dot",
                              "w-1": indicator === "line",
                              "w-0 border-[1.5px] border-dashed bg-transparent":
                                indicator === "dashed",
                              "my-0.5": nestLabel && indicator === "dashed",
                            }
                          )}
                          style={
                            {
                              "--color-bg": indicatorColor,
                              "--color-border": indicatorColor,
                            } as React.CSSProperties
                          }
                        />
                      )
                    )}
                    <div
                      className={cn(
                        "flex flex-1 justify-between leading-none",
                        nestLabel ? "items-end" : "items-center"
                      )}
                    >
                      <div className="grid gap-1.5">
                        {nestLabel ? tooltipLabel : null}
                        <span className="text-muted-foreground">
                          {itemConfig?.label || item.name}
                        </span>
                      </div>
                      {item.value && (
                        <span className="font-mono font-medium tabular-nums text-foreground">
                          {item.value.toLocaleString()}
                        </span>
                      )}
                    </div>
                  </>
                )}
              </div>
            )
          })}
        </div>
      </div>
    )
  }
)
ChartTooltipContent.displayName = "ChartTooltip"

const ChartLegend = RechartsPrimitive.Legend

const ChartLegendContent = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div"> &
    Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
      hideIcon?: boolean
      nameKey?: string
    }
>(
  (
    { className, hideIcon = false, payload, verticalAlign = "bottom", nameKey },
    ref
  ) => {
    const { config } = useChart()

if (!payload?.length) {
      return null
    }

return (
      <div
        ref={ref}
        className={cn(
          "flex items-center justify-center gap-4",
          verticalAlign === "top" ? "pb-3" : "pt-3",
          className
        )}
      >
        {payload.map((item) => {
          const key = `${nameKey || item.dataKey || "value"}`
          const itemConfig = getPayloadConfigFromPayload(config, item, key)

return (
            <div
              key={item.value}
              className={cn(
                "flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground"
              )}
            >
              {itemConfig?.icon && !hideIcon ? (
                <itemConfig.icon />
              ) : (
                <div
                  className="h-2 w-2 shrink-0 rounded-[2px]"
                  style={{
                    backgroundColor: item.color,
                  }}
                />
              )}
              {itemConfig?.label}
            </div>
          )
        })}
      </div>
    )
  }
)
ChartLegendContent.displayName = "ChartLegend"

// Helper to extract item config from a payload.
function getPayloadConfigFromPayload(
  config: ChartConfig,
  payload: unknown,
  key: string
) {
  if (typeof payload !== "object" || payload === null) {
    return undefined
  }

const payloadPayload =
    "payload" in payload &&
    typeof payload.payload === "object" &&
    payload.payload !== null
      ? payload.payload
      : undefined

let configLabelKey: string = key

if (
    key in payload &&
    typeof payload[key as keyof typeof payload] === "string"
  ) {
    configLabelKey = payload[key as keyof typeof payload] as string
  } else if (
    payloadPayload &&
    key in payloadPayload &&
    typeof payloadPayload[key as keyof typeof payloadPayload] === "string"
  ) {
    configLabelKey = payloadPayload[
      key as keyof typeof payloadPayload
    ] as string
  }

return configLabelKey in config
    ? config[configLabelKey]
    : config[key as keyof typeof config]
}

export {
  ChartContainer,
  ChartTooltip,
  ChartTooltipContent,
  ChartLegend,
  ChartLegendContent,
  ChartStyle,
}
[V0_FILE]typescriptreact:file="components/ui/checkbox.tsx"
"use client"

import * as React from "react"
import * as CheckboxPrimitive from "@radix-ui/react-checkbox"
import { Check } from "lucide-react"

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

const Checkbox = React.forwardRef<
  React.ElementRef<typeof CheckboxPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>
>(({ className, ...props }, ref) => (
  <CheckboxPrimitive.Root
    ref={ref}
    className={cn(
      "peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
      className
    )}
    {...props}
  >
    <CheckboxPrimitive.Indicator
      className={cn("flex items-center justify-center text-current")}
    >
      <Check className="h-4 w-4" />
    </CheckboxPrimitive.Indicator>
  </CheckboxPrimitive.Root>
))
Checkbox.displayName = CheckboxPrimitive.Root.displayName

export { Checkbox }
[V0_FILE]typescriptreact:file="components/ui/collapsible.tsx"
"use client"

import * as CollapsiblePrimitive from "@radix-ui/react-collapsible"

const Collapsible = CollapsiblePrimitive.Root

const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger

const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent

export { Collapsible, CollapsibleTrigger, CollapsibleContent }
[V0_FILE]typescriptreact:file="components/ui/command.tsx"
"use client"

import * as React from "react"
import { type DialogProps } from "@radix-ui/react-dialog"
import { Command as CommandPrimitive } from "cmdk"
import { Search } from "lucide-react"

import { cn } from "@/lib/utils"
import { Dialog, DialogContent } from "@/components/ui/dialog"

const Command = React.forwardRef<
  React.ElementRef<typeof CommandPrimitive>,
  React.ComponentPropsWithoutRef<typeof CommandPrimitive>
>(({ className, ...props }, ref) => (
  <CommandPrimitive
    ref={ref}
    className={cn(
      "flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground",
      className
    )}
    {...props}
  />
))
Command.displayName = CommandPrimitive.displayName

const CommandDialog = ({ children, ...props }: DialogProps) => {
  return (
    <Dialog {...props}>
      <DialogContent className="overflow-hidden p-0 shadow-lg">
        <Command className="[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-group]]:px-2 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5">
          {children}
        </Command>
      </DialogContent>
    </Dialog>
  )
}

const CommandInput = React.forwardRef<
  React.ElementRef<typeof CommandPrimitive.Input>,
  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Input>
>(({ className, ...props }, ref) => (
  <div className="flex items-center border-b px-3" cmdk-input-wrapper="">
    <Search className="mr-2 h-4 w-4 shrink-0 opacity-50" />
    <CommandPrimitive.Input
      ref={ref}
      className={cn(
        "flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50",
        className
      )}
      {...props}
    />
  </div>
))

CommandInput.displayName = CommandPrimitive.Input.displayName

const CommandList = React.forwardRef<
  React.ElementRef<typeof CommandPrimitive.List>,
  React.ComponentPropsWithoutRef<typeof CommandPrimitive.List>
>(({ className, ...props }, ref) => (
  <CommandPrimitive.List
    ref={ref}
    className={cn("max-h-[300px] overflow-y-auto overflow-x-hidden", className)}
    {...props}
  />
))

CommandList.displayName = CommandPrimitive.List.displayName

const CommandEmpty = React.forwardRef<
  React.ElementRef<typeof CommandPrimitive.Empty>,
  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Empty>
>((props, ref) => (
  <CommandPrimitive.Empty
    ref={ref}
    className="py-6 text-center text-sm"
    {...props}
  />
))

CommandEmpty.displayName = CommandPrimitive.Empty.displayName

const CommandGroup = React.forwardRef<
  React.ElementRef<typeof CommandPrimitive.Group>,
  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Group>
>(({ className, ...props }, ref) => (
  <CommandPrimitive.Group
    ref={ref}
    className={cn(
      "overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground",
      className
    )}
    {...props}
  />
))

CommandGroup.displayName = CommandPrimitive.Group.displayName

const CommandSeparator = React.forwardRef<
  React.ElementRef<typeof CommandPrimitive.Separator>,
  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Separator>
>(({ className, ...props }, ref) => (
  <CommandPrimitive.Separator
    ref={ref}
    className={cn("-mx-1 h-px bg-border", className)}
    {...props}
  />
))
CommandSeparator.displayName = CommandPrimitive.Separator.displayName

const CommandItem = React.forwardRef<
  React.ElementRef<typeof CommandPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof CommandPrimitive.Item>
>(({ className, ...props }, ref) => (
  <CommandPrimitive.Item
    ref={ref}
    className={cn(
      "relative flex cursor-default gap-2 select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none data-[disabled=true]:pointer-events-none data-[selected='true']:bg-accent data-[selected=true]:text-accent-foreground data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
      className
    )}
    {...props}
  />
))

CommandItem.displayName = CommandPrimitive.Item.displayName

const CommandShortcut = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
  return (
    <span
      className={cn(
        "ml-auto text-xs tracking-widest text-muted-foreground",
        className
      )}
      {...props}
    />
  )
}
CommandShortcut.displayName = "CommandShortcut"

export {
  Command,
  CommandDialog,
  CommandInput,
  CommandList,
  CommandEmpty,
  CommandGroup,
  CommandItem,
  CommandShortcut,
  CommandSeparator,
}
[V0_FILE]typescriptreact:file="components/ui/context-menu.tsx"
"use client"

import * as React from "react"
import * as ContextMenuPrimitive from "@radix-ui/react-context-menu"
import { Check, ChevronRight, Circle } from "lucide-react"

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

const ContextMenu = ContextMenuPrimitive.Root

const ContextMenuTrigger = ContextMenuPrimitive.Trigger

const ContextMenuGroup = ContextMenuPrimitive.Group

const ContextMenuPortal = ContextMenuPrimitive.Portal

const ContextMenuSub = ContextMenuPrimitive.Sub

const ContextMenuRadioGroup = ContextMenuPrimitive.RadioGroup

const ContextMenuSubTrigger = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.SubTrigger>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubTrigger> & {
    inset?: boolean
  }
>(({ className, inset, children, ...props }, ref) => (
  <ContextMenuPrimitive.SubTrigger
    ref={ref}
    className={cn(
      "flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground",
      inset && "pl-8",
      className
    )}
    {...props}
  >
    {children}
    <ChevronRight className="ml-auto h-4 w-4" />
  </ContextMenuPrimitive.SubTrigger>
))
ContextMenuSubTrigger.displayName = ContextMenuPrimitive.SubTrigger.displayName

const ContextMenuSubContent = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.SubContent>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubContent>
>(({ className, ...props }, ref) => (
  <ContextMenuPrimitive.SubContent
    ref={ref}
    className={cn(
      "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
      className
    )}
    {...props}
  />
))
ContextMenuSubContent.displayName = ContextMenuPrimitive.SubContent.displayName

const ContextMenuContent = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content>
>(({ className, ...props }, ref) => (
  <ContextMenuPrimitive.Portal>
    <ContextMenuPrimitive.Content
      ref={ref}
      className={cn(
        "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md animate-in fade-in-80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
        className
      )}
      {...props}
    />
  </ContextMenuPrimitive.Portal>
))
ContextMenuContent.displayName = ContextMenuPrimitive.Content.displayName

const ContextMenuItem = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Item> & {
    inset?: boolean
  }
>(({ className, inset, ...props }, ref) => (
  <ContextMenuPrimitive.Item
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      inset && "pl-8",
      className
    )}
    {...props}
  />
))
ContextMenuItem.displayName = ContextMenuPrimitive.Item.displayName

const ContextMenuCheckboxItem = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.CheckboxItem>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.CheckboxItem>
>(({ className, children, checked, ...props }, ref) => (
  <ContextMenuPrimitive.CheckboxItem
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      className
    )}
    checked={checked}
    {...props}
  >
    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
      <ContextMenuPrimitive.ItemIndicator>
        <Check className="h-4 w-4" />
      </ContextMenuPrimitive.ItemIndicator>
    </span>
    {children}
  </ContextMenuPrimitive.CheckboxItem>
))
ContextMenuCheckboxItem.displayName =
  ContextMenuPrimitive.CheckboxItem.displayName

const ContextMenuRadioItem = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.RadioItem>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.RadioItem>
>(({ className, children, ...props }, ref) => (
  <ContextMenuPrimitive.RadioItem
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      className
    )}
    {...props}
  >
    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
      <ContextMenuPrimitive.ItemIndicator>
        <Circle className="h-2 w-2 fill-current" />
      </ContextMenuPrimitive.ItemIndicator>
    </span>
    {children}
  </ContextMenuPrimitive.RadioItem>
))
ContextMenuRadioItem.displayName = ContextMenuPrimitive.RadioItem.displayName

const ContextMenuLabel = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.Label>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Label> & {
    inset?: boolean
  }
>(({ className, inset, ...props }, ref) => (
  <ContextMenuPrimitive.Label
    ref={ref}
    className={cn(
      "px-2 py-1.5 text-sm font-semibold text-foreground",
      inset && "pl-8",
      className
    )}
    {...props}
  />
))
ContextMenuLabel.displayName = ContextMenuPrimitive.Label.displayName

const ContextMenuSeparator = React.forwardRef<
  React.ElementRef<typeof ContextMenuPrimitive.Separator>,
  React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Separator>
>(({ className, ...props }, ref) => (
  <ContextMenuPrimitive.Separator
    ref={ref}
    className={cn("-mx-1 my-1 h-px bg-border", className)}
    {...props}
  />
))
ContextMenuSeparator.displayName = ContextMenuPrimitive.Separator.displayName

const ContextMenuShortcut = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
  return (
    <span
      className={cn(
        "ml-auto text-xs tracking-widest text-muted-foreground",
        className
      )}
      {...props}
    />
  )
}
ContextMenuShortcut.displayName = "ContextMenuShortcut"

export {
  ContextMenu,
  ContextMenuTrigger,
  ContextMenuContent,
  ContextMenuItem,
  ContextMenuCheckboxItem,
  ContextMenuRadioItem,
  ContextMenuLabel,
  ContextMenuSeparator,
  ContextMenuShortcut,
  ContextMenuGroup,
  ContextMenuPortal,
  ContextMenuSub,
  ContextMenuSubContent,
  ContextMenuSubTrigger,
  ContextMenuRadioGroup,
}
[V0_FILE]typescriptreact:file="components/ui/dialog.tsx"
"use client"

import * as React from "react"
import * as DialogPrimitive from "@radix-ui/react-dialog"
import { X } from "lucide-react"

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

const Dialog = DialogPrimitive.Root

const DialogTrigger = DialogPrimitive.Trigger

const DialogPortal = DialogPrimitive.Portal

const DialogClose = DialogPrimitive.Close

const DialogOverlay = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Overlay>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
>(({ className, ...props }, ref) => (
  <DialogPrimitive.Overlay
    ref={ref}
    className={cn(
      "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
      className,
    )}
    {...props}
  />
))
DialogOverlay.displayName = DialogPrimitive.Overlay.displayName

const DialogContent = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>
>(({ className, children, ...props }, ref) => (
  <DialogPortal>
    <DialogOverlay />
    <DialogPrimitive.Content
      ref={ref}
      className={cn(
        "fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
        className,
      )}
      {...props}
    >
      {children}
      <DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
        <X className="h-4 w-4" />
        <span className="sr-only">Close</span>
      </DialogPrimitive.Close>
    </DialogPrimitive.Content>
  </DialogPortal>
))
DialogContent.displayName = DialogPrimitive.Content.displayName

const DialogHeader = ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
  <div className={cn("flex flex-col space-y-1.5 text-center sm:text-left", className)} {...props} />
)
DialogHeader.displayName = "DialogHeader"

const DialogFooter = ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
  <div className={cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className)} {...props} />
)
DialogFooter.displayName = "DialogFooter"

const DialogTitle = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Title>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
>(({ className, ...props }, ref) => (
  <DialogPrimitive.Title
    ref={ref}
    className={cn("text-lg font-semibold leading-none tracking-tight", className)}
    {...props}
  />
))
DialogTitle.displayName = DialogPrimitive.Title.displayName

const DialogDescription = React.forwardRef<
  React.ElementRef<typeof DialogPrimitive.Description>,
  React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
>(({ className, ...props }, ref) => (
  <DialogPrimitive.Description ref={ref} className={cn("text-sm text-muted-foreground", className)} {...props} />
))
DialogDescription.displayName = DialogPrimitive.Description.displayName

export {
  Dialog,
  DialogPortal,
  DialogOverlay,
  DialogClose,
  DialogTrigger,
  DialogContent,
  DialogHeader,
  DialogFooter,
  DialogTitle,
  DialogDescription,
}
[V0_FILE]typescriptreact:file="components/ui/drawer.tsx"
"use client"

import * as React from "react"
import { Drawer as DrawerPrimitive } from "vaul"

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

const Drawer = ({
  shouldScaleBackground = true,
  ...props
}: React.ComponentProps<typeof DrawerPrimitive.Root>) => (
  <DrawerPrimitive.Root
    shouldScaleBackground={shouldScaleBackground}
    {...props}
  />
)
Drawer.displayName = "Drawer"

const DrawerTrigger = DrawerPrimitive.Trigger

const DrawerPortal = DrawerPrimitive.Portal

const DrawerClose = DrawerPrimitive.Close

const DrawerOverlay = React.forwardRef<
  React.ElementRef<typeof DrawerPrimitive.Overlay>,
  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Overlay>
>(({ className, ...props }, ref) => (
  <DrawerPrimitive.Overlay
    ref={ref}
    className={cn("fixed inset-0 z-50 bg-black/80", className)}
    {...props}
  />
))
DrawerOverlay.displayName = DrawerPrimitive.Overlay.displayName

const DrawerContent = React.forwardRef<
  React.ElementRef<typeof DrawerPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Content>
>(({ className, children, ...props }, ref) => (
  <DrawerPortal>
    <DrawerOverlay />
    <DrawerPrimitive.Content
      ref={ref}
      className={cn(
        "fixed inset-x-0 bottom-0 z-50 mt-24 flex h-auto flex-col rounded-t-[10px] border bg-background",
        className
      )}
      {...props}
    >
      <div className="mx-auto mt-4 h-2 w-[100px] rounded-full bg-muted" />
      {children}
    </DrawerPrimitive.Content>
  </DrawerPortal>
))
DrawerContent.displayName = "DrawerContent"

const DrawerHeader = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn("grid gap-1.5 p-4 text-center sm:text-left", className)}
    {...props}
  />
)
DrawerHeader.displayName = "DrawerHeader"

const DrawerFooter = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn("mt-auto flex flex-col gap-2 p-4", className)}
    {...props}
  />
)
DrawerFooter.displayName = "DrawerFooter"

const DrawerTitle = React.forwardRef<
  React.ElementRef<typeof DrawerPrimitive.Title>,
  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Title>
>(({ className, ...props }, ref) => (
  <DrawerPrimitive.Title
    ref={ref}
    className={cn(
      "text-lg font-semibold leading-none tracking-tight",
      className
    )}
    {...props}
  />
))
DrawerTitle.displayName = DrawerPrimitive.Title.displayName

const DrawerDescription = React.forwardRef<
  React.ElementRef<typeof DrawerPrimitive.Description>,
  React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Description>
>(({ className, ...props }, ref) => (
  <DrawerPrimitive.Description
    ref={ref}
    className={cn("text-sm text-muted-foreground", className)}
    {...props}
  />
))
DrawerDescription.displayName = DrawerPrimitive.Description.displayName

export {
  Drawer,
  DrawerPortal,
  DrawerOverlay,
  DrawerTrigger,
  DrawerClose,
  DrawerContent,
  DrawerHeader,
  DrawerFooter,
  DrawerTitle,
  DrawerDescription,
}
[V0_FILE]typescriptreact:file="components/ui/dropdown-menu.tsx"
"use client"

import * as React from "react"
import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu"
import { Check, ChevronRight, Circle } from "lucide-react"

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

const DropdownMenu = DropdownMenuPrimitive.Root

const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger

const DropdownMenuGroup = DropdownMenuPrimitive.Group

const DropdownMenuPortal = DropdownMenuPrimitive.Portal

const DropdownMenuSub = DropdownMenuPrimitive.Sub

const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup

const DropdownMenuSubTrigger = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.SubTrigger>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
    inset?: boolean
  }
>(({ className, inset, children, ...props }, ref) => (
  <DropdownMenuPrimitive.SubTrigger
    ref={ref}
    className={cn(
      "flex cursor-default gap-2 select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
      inset && "pl-8",
      className
    )}
    {...props}
  >
    {children}
    <ChevronRight className="ml-auto" />
  </DropdownMenuPrimitive.SubTrigger>
))
DropdownMenuSubTrigger.displayName =
  DropdownMenuPrimitive.SubTrigger.displayName

const DropdownMenuSubContent = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.SubContent>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent>
>(({ className, ...props }, ref) => (
  <DropdownMenuPrimitive.SubContent
    ref={ref}
    className={cn(
      "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
      className
    )}
    {...props}
  />
))
DropdownMenuSubContent.displayName =
  DropdownMenuPrimitive.SubContent.displayName

const DropdownMenuContent = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>
>(({ className, sideOffset = 4, ...props }, ref) => (
  <DropdownMenuPrimitive.Portal>
    <DropdownMenuPrimitive.Content
      ref={ref}
      sideOffset={sideOffset}
      className={cn(
        "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
        className
      )}
      {...props}
    />
  </DropdownMenuPrimitive.Portal>
))
DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName

const DropdownMenuItem = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
    inset?: boolean
  }
>(({ className, inset, ...props }, ref) => (
  <DropdownMenuPrimitive.Item
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
      inset && "pl-8",
      className
    )}
    {...props}
  />
))
DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName

const DropdownMenuCheckboxItem = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.CheckboxItem>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem>
>(({ className, children, checked, ...props }, ref) => (
  <DropdownMenuPrimitive.CheckboxItem
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      className
    )}
    checked={checked}
    {...props}
  >
    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
      <DropdownMenuPrimitive.ItemIndicator>
        <Check className="h-4 w-4" />
      </DropdownMenuPrimitive.ItemIndicator>
    </span>
    {children}
  </DropdownMenuPrimitive.CheckboxItem>
))
DropdownMenuCheckboxItem.displayName =
  DropdownMenuPrimitive.CheckboxItem.displayName

const DropdownMenuRadioItem = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.RadioItem>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.RadioItem>
>(({ className, children, ...props }, ref) => (
  <DropdownMenuPrimitive.RadioItem
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      className
    )}
    {...props}
  >
    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
      <DropdownMenuPrimitive.ItemIndicator>
        <Circle className="h-2 w-2 fill-current" />
      </DropdownMenuPrimitive.ItemIndicator>
    </span>
    {children}
  </DropdownMenuPrimitive.RadioItem>
))
DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName

const DropdownMenuLabel = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.Label>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
    inset?: boolean
  }
>(({ className, inset, ...props }, ref) => (
  <DropdownMenuPrimitive.Label
    ref={ref}
    className={cn(
      "px-2 py-1.5 text-sm font-semibold",
      inset && "pl-8",
      className
    )}
    {...props}
  />
))
DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName

const DropdownMenuSeparator = React.forwardRef<
  React.ElementRef<typeof DropdownMenuPrimitive.Separator>,
  React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator>
>(({ className, ...props }, ref) => (
  <DropdownMenuPrimitive.Separator
    ref={ref}
    className={cn("-mx-1 my-1 h-px bg-muted", className)}
    {...props}
  />
))
DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName

const DropdownMenuShortcut = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
  return (
    <span
      className={cn("ml-auto text-xs tracking-widest opacity-60", className)}
      {...props}
    />
  )
}
DropdownMenuShortcut.displayName = "DropdownMenuShortcut"

export {
  DropdownMenu,
  DropdownMenuTrigger,
  DropdownMenuContent,
  DropdownMenuItem,
  DropdownMenuCheckboxItem,
  DropdownMenuRadioItem,
  DropdownMenuLabel,
  DropdownMenuSeparator,
  DropdownMenuShortcut,
  DropdownMenuGroup,
  DropdownMenuPortal,
  DropdownMenuSub,
  DropdownMenuSubContent,
  DropdownMenuSubTrigger,
  DropdownMenuRadioGroup,
}
[V0_FILE]typescriptreact:file="components/ui/form.tsx"
"use client"

import * as React from "react"
import * as LabelPrimitive from "@radix-ui/react-label"
import { Slot } from "@radix-ui/react-slot"
import {
  Controller,
  ControllerProps,
  FieldPath,
  FieldValues,
  FormProvider,
  useFormContext,
} from "react-hook-form"

import { cn } from "@/lib/utils"
import { Label } from "@/components/ui/label"

const Form = FormProvider

type FormFieldContextValue<
  TFieldValues extends FieldValues = FieldValues,
  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>
> = {
  name: TName
}

const FormFieldContext = React.createContext<FormFieldContextValue>(
  {} as FormFieldContextValue
)

const FormField = <
  TFieldValues extends FieldValues = FieldValues,
  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>
>({
  ...props
}: ControllerProps<TFieldValues, TName>) => {
  return (
    <FormFieldContext.Provider value={{ name: props.name }}>
      <Controller {...props} />
    </FormFieldContext.Provider>
  )
}

const useFormField = () => {
  const fieldContext = React.useContext(FormFieldContext)
  const itemContext = React.useContext(FormItemContext)
  const { getFieldState, formState } = useFormContext()

const fieldState = getFieldState(fieldContext.name, formState)

if (!fieldContext) {
    throw new Error("useFormField should be used within <FormField>")
  }

const { id } = itemContext

return {
    id,
    name: fieldContext.name,
    formItemId: `${id}-form-item`,
    formDescriptionId: `${id}-form-item-description`,
    formMessageId: `${id}-form-item-message`,
    ...fieldState,
  }
}

type FormItemContextValue = {
  id: string
}

const FormItemContext = React.createContext<FormItemContextValue>(
  {} as FormItemContextValue
)

const FormItem = React.forwardRef<
  HTMLDivElement,
  React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => {
  const id = React.useId()

return (
    <FormItemContext.Provider value={{ id }}>
      <div ref={ref} className={cn("space-y-2", className)} {...props} />
    </FormItemContext.Provider>
  )
})
FormItem.displayName = "FormItem"

const FormLabel = React.forwardRef<
  React.ElementRef<typeof LabelPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>
>(({ className, ...props }, ref) => {
  const { error, formItemId } = useFormField()

return (
    <Label
      ref={ref}
      className={cn(error && "text-destructive", className)}
      htmlFor={formItemId}
      {...props}
    />
  )
})
FormLabel.displayName = "FormLabel"

const FormControl = React.forwardRef<
  React.ElementRef<typeof Slot>,
  React.ComponentPropsWithoutRef<typeof Slot>
>(({ ...props }, ref) => {
  const { error, formItemId, formDescriptionId, formMessageId } = useFormField()

return (
    <Slot
      ref={ref}
      id={formItemId}
      aria-describedby={
        !error
          ? `${formDescriptionId}`
          : `${formDescriptionId} ${formMessageId}`
      }
      aria-invalid={!!error}
      {...props}
    />
  )
})
FormControl.displayName = "FormControl"

const FormDescription = React.forwardRef<
  HTMLParagraphElement,
  React.HTMLAttributes<HTMLParagraphElement>
>(({ className, ...props }, ref) => {
  const { formDescriptionId } = useFormField()

return (
    <p
      ref={ref}
      id={formDescriptionId}
      className={cn("text-sm text-muted-foreground", className)}
      {...props}
    />
  )
})
FormDescription.displayName = "FormDescription"

const FormMessage = React.forwardRef<
  HTMLParagraphElement,
  React.HTMLAttributes<HTMLParagraphElement>
>(({ className, children, ...props }, ref) => {
  const { error, formMessageId } = useFormField()
  const body = error ? String(error?.message) : children

if (!body) {
    return null
  }

return (
    <p
      ref={ref}
      id={formMessageId}
      className={cn("text-sm font-medium text-destructive", className)}
      {...props}
    >
      {body}
    </p>
  )
})
FormMessage.displayName = "FormMessage"

export {
  useFormField,
  Form,
  FormItem,
  FormLabel,
  FormControl,
  FormDescription,
  FormMessage,
  FormField,
}
[V0_FILE]typescriptreact:file="components/ui/hover-card.tsx"
"use client"

import * as React from "react"
import * as HoverCardPrimitive from "@radix-ui/react-hover-card"

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

const HoverCard = HoverCardPrimitive.Root

const HoverCardTrigger = HoverCardPrimitive.Trigger

const HoverCardContent = React.forwardRef<
  React.ElementRef<typeof HoverCardPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof HoverCardPrimitive.Content>
>(({ className, align = "center", sideOffset = 4, ...props }, ref) => (
  <HoverCardPrimitive.Content
    ref={ref}
    align={align}
    sideOffset={sideOffset}
    className={cn(
      "z-50 w-64 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
      className
    )}
    {...props}
  />
))
HoverCardContent.displayName = HoverCardPrimitive.Content.displayName

export { HoverCard, HoverCardTrigger, HoverCardContent }
[V0_FILE]typescriptreact:file="components/ui/input-otp.tsx"
"use client"

import * as React from "react"
import { OTPInput, OTPInputContext } from "input-otp"
import { Dot } from "lucide-react"

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

const InputOTP = React.forwardRef<
  React.ElementRef<typeof OTPInput>,
  React.ComponentPropsWithoutRef<typeof OTPInput>
>(({ className, containerClassName, ...props }, ref) => (
  <OTPInput
    ref={ref}
    containerClassName={cn(
      "flex items-center gap-2 has-[:disabled]:opacity-50",
      containerClassName
    )}
    className={cn("disabled:cursor-not-allowed", className)}
    {...props}
  />
))
InputOTP.displayName = "InputOTP"

const InputOTPGroup = React.forwardRef<
  React.ElementRef<"div">,
  React.ComponentPropsWithoutRef<"div">
>(({ className, ...props }, ref) => (
  <div ref={ref} className={cn("flex items-center", className)} {...props} />
))
InputOTPGroup.displayName = "InputOTPGroup"

const InputOTPSlot = React.forwardRef<
  React.ElementRef<"div">,
  React.ComponentPropsWithoutRef<"div"> & { index: number }
>(({ index, className, ...props }, ref) => {
  const inputOTPContext = React.useContext(OTPInputContext)
  const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index]

return (
    <div
      ref={ref}
      className={cn(
        "relative flex h-10 w-10 items-center justify-center border-y border-r border-input text-sm transition-all first:rounded-l-md first:border-l last:rounded-r-md",
        isActive && "z-10 ring-2 ring-ring ring-offset-background",
        className
      )}
      {...props}
    >
      {char}
      {hasFakeCaret && (
        <div className="pointer-events-none absolute inset-0 flex items-center justify-center">
          <div className="h-4 w-px animate-caret-blink bg-foreground duration-1000" />
        </div>
      )}
    </div>
  )
})
InputOTPSlot.displayName = "InputOTPSlot"

const InputOTPSeparator = React.forwardRef<
  React.ElementRef<"div">,
  React.ComponentPropsWithoutRef<"div">
>(({ ...props }, ref) => (
  <div ref={ref} role="separator" {...props}>
    <Dot />
  </div>
))
InputOTPSeparator.displayName = "InputOTPSeparator"

export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator }
[V0_FILE]typescriptreact:file="components/ui/input.tsx"
import * as React from "react"

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

const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(
  ({ className, type, ...props }, ref) => {
    return (
      <input
        type={type}
        className={cn(
          "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
          className
        )}
        ref={ref}
        {...props}
      />
    )
  }
)
Input.displayName = "Input"

export { Input }
[V0_FILE]typescriptreact:file="components/ui/label.tsx"
"use client"

import * as React from "react"
import * as LabelPrimitive from "@radix-ui/react-label"
import { cva, type VariantProps } from "class-variance-authority"

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

const labelVariants = cva(
  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
)

const Label = React.forwardRef<
  React.ElementRef<typeof LabelPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> &
    VariantProps<typeof labelVariants>
>(({ className, ...props }, ref) => (
  <LabelPrimitive.Root
    ref={ref}
    className={cn(labelVariants(), className)}
    {...props}
  />
))
Label.displayName = LabelPrimitive.Root.displayName

export { Label }
[V0_FILE]typescriptreact:file="components/ui/menubar.tsx"
"use client"

import * as React from "react"
import * as MenubarPrimitive from "@radix-ui/react-menubar"
import { Check, ChevronRight, Circle } from "lucide-react"

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

const MenubarMenu = MenubarPrimitive.Menu

const MenubarGroup = MenubarPrimitive.Group

const MenubarPortal = MenubarPrimitive.Portal

const MenubarSub = MenubarPrimitive.Sub

const MenubarRadioGroup = MenubarPrimitive.RadioGroup

const Menubar = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Root>
>(({ className, ...props }, ref) => (
  <MenubarPrimitive.Root
    ref={ref}
    className={cn(
      "flex h-10 items-center space-x-1 rounded-md border bg-background p-1",
      className
    )}
    {...props}
  />
))
Menubar.displayName = MenubarPrimitive.Root.displayName

const MenubarTrigger = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.Trigger>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Trigger>
>(({ className, ...props }, ref) => (
  <MenubarPrimitive.Trigger
    ref={ref}
    className={cn(
      "flex cursor-default select-none items-center rounded-sm px-3 py-1.5 text-sm font-medium outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground",
      className
    )}
    {...props}
  />
))
MenubarTrigger.displayName = MenubarPrimitive.Trigger.displayName

const MenubarSubTrigger = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.SubTrigger>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubTrigger> & {
    inset?: boolean
  }
>(({ className, inset, children, ...props }, ref) => (
  <MenubarPrimitive.SubTrigger
    ref={ref}
    className={cn(
      "flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground",
      inset && "pl-8",
      className
    )}
    {...props}
  >
    {children}
    <ChevronRight className="ml-auto h-4 w-4" />
  </MenubarPrimitive.SubTrigger>
))
MenubarSubTrigger.displayName = MenubarPrimitive.SubTrigger.displayName

const MenubarSubContent = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.SubContent>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubContent>
>(({ className, ...props }, ref) => (
  <MenubarPrimitive.SubContent
    ref={ref}
    className={cn(
      "z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
      className
    )}
    {...props}
  />
))
MenubarSubContent.displayName = MenubarPrimitive.SubContent.displayName

const MenubarContent = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Content>
>(
  (
    { className, align = "start", alignOffset = -4, sideOffset = 8, ...props },
    ref
  ) => (
    <MenubarPrimitive.Portal>
      <MenubarPrimitive.Content
        ref={ref}
        align={align}
        alignOffset={alignOffset}
        sideOffset={sideOffset}
        className={cn(
          "z-50 min-w-[12rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
          className
        )}
        {...props}
      />
    </MenubarPrimitive.Portal>
  )
)
MenubarContent.displayName = MenubarPrimitive.Content.displayName

const MenubarItem = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Item> & {
    inset?: boolean
  }
>(({ className, inset, ...props }, ref) => (
  <MenubarPrimitive.Item
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      inset && "pl-8",
      className
    )}
    {...props}
  />
))
MenubarItem.displayName = MenubarPrimitive.Item.displayName

const MenubarCheckboxItem = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.CheckboxItem>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.CheckboxItem>
>(({ className, children, checked, ...props }, ref) => (
  <MenubarPrimitive.CheckboxItem
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      className
    )}
    checked={checked}
    {...props}
  >
    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
      <MenubarPrimitive.ItemIndicator>
        <Check className="h-4 w-4" />
      </MenubarPrimitive.ItemIndicator>
    </span>
    {children}
  </MenubarPrimitive.CheckboxItem>
))
MenubarCheckboxItem.displayName = MenubarPrimitive.CheckboxItem.displayName

const MenubarRadioItem = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.RadioItem>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.RadioItem>
>(({ className, children, ...props }, ref) => (
  <MenubarPrimitive.RadioItem
    ref={ref}
    className={cn(
      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      className
    )}
    {...props}
  >
    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
      <MenubarPrimitive.ItemIndicator>
        <Circle className="h-2 w-2 fill-current" />
      </MenubarPrimitive.ItemIndicator>
    </span>
    {children}
  </MenubarPrimitive.RadioItem>
))
MenubarRadioItem.displayName = MenubarPrimitive.RadioItem.displayName

const MenubarLabel = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.Label>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Label> & {
    inset?: boolean
  }
>(({ className, inset, ...props }, ref) => (
  <MenubarPrimitive.Label
    ref={ref}
    className={cn(
      "px-2 py-1.5 text-sm font-semibold",
      inset && "pl-8",
      className
    )}
    {...props}
  />
))
MenubarLabel.displayName = MenubarPrimitive.Label.displayName

const MenubarSeparator = React.forwardRef<
  React.ElementRef<typeof MenubarPrimitive.Separator>,
  React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Separator>
>(({ className, ...props }, ref) => (
  <MenubarPrimitive.Separator
    ref={ref}
    className={cn("-mx-1 my-1 h-px bg-muted", className)}
    {...props}
  />
))
MenubarSeparator.displayName = MenubarPrimitive.Separator.displayName

const MenubarShortcut = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
  return (
    <span
      className={cn(
        "ml-auto text-xs tracking-widest text-muted-foreground",
        className
      )}
      {...props}
    />
  )
}
MenubarShortcut.displayname = "MenubarShortcut"

export {
  Menubar,
  MenubarMenu,
  MenubarTrigger,
  MenubarContent,
  MenubarItem,
  MenubarSeparator,
  MenubarLabel,
  MenubarCheckboxItem,
  MenubarRadioGroup,
  MenubarRadioItem,
  MenubarPortal,
  MenubarSubContent,
  MenubarSubTrigger,
  MenubarGroup,
  MenubarSub,
  MenubarShortcut,
}
[V0_FILE]typescriptreact:file="components/ui/navigation-menu.tsx"
import * as React from "react"
import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu"
import { cva } from "class-variance-authority"
import { ChevronDown } from "lucide-react"

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

const NavigationMenu = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Root>
>(({ className, children, ...props }, ref) => (
  <NavigationMenuPrimitive.Root
    ref={ref}
    className={cn(
      "relative z-10 flex max-w-max flex-1 items-center justify-center",
      className
    )}
    {...props}
  >
    {children}
    <NavigationMenuViewport />
  </NavigationMenuPrimitive.Root>
))
NavigationMenu.displayName = NavigationMenuPrimitive.Root.displayName

const NavigationMenuList = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.List>,
  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.List>
>(({ className, ...props }, ref) => (
  <NavigationMenuPrimitive.List
    ref={ref}
    className={cn(
      "group flex flex-1 list-none items-center justify-center space-x-1",
      className
    )}
    {...props}
  />
))
NavigationMenuList.displayName = NavigationMenuPrimitive.List.displayName

const NavigationMenuItem = NavigationMenuPrimitive.Item

const navigationMenuTriggerStyle = cva(
  "group inline-flex h-10 w-max items-center justify-center rounded-md bg-background px-4 py-2 text-sm font-medium transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus:outline-none disabled:pointer-events-none disabled:opacity-50 data-[active]:bg-accent/50 data-[state=open]:bg-accent/50"
)

const NavigationMenuTrigger = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Trigger>,
  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Trigger>
>(({ className, children, ...props }, ref) => (
  <NavigationMenuPrimitive.Trigger
    ref={ref}
    className={cn(navigationMenuTriggerStyle(), "group", className)}
    {...props}
  >
    {children}{" "}
    <ChevronDown
      className="relative top-[1px] ml-1 h-3 w-3 transition duration-200 group-data-[state=open]:rotate-180"
      aria-hidden="true"
    />
  </NavigationMenuPrimitive.Trigger>
))
NavigationMenuTrigger.displayName = NavigationMenuPrimitive.Trigger.displayName

const NavigationMenuContent = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Content>
>(({ className, ...props }, ref) => (
  <NavigationMenuPrimitive.Content
    ref={ref}
    className={cn(
      "left-0 top-0 w-full data-[motion^=from-]:animate-in data-[motion^=to-]:animate-out data-[motion^=from-]:fade-in data-[motion^=to-]:fade-out data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 md:absolute md:w-auto ",
      className
    )}
    {...props}
  />
))
NavigationMenuContent.displayName = NavigationMenuPrimitive.Content.displayName

const NavigationMenuLink = NavigationMenuPrimitive.Link

const NavigationMenuViewport = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Viewport>,
  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Viewport>
>(({ className, ...props }, ref) => (
  <div className={cn("absolute left-0 top-full flex justify-center")}>
    <NavigationMenuPrimitive.Viewport
      className={cn(
        "origin-top-center relative mt-1.5 h-[var(--radix-navigation-menu-viewport-height)] w-full overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-90 md:w-[var(--radix-navigation-menu-viewport-width)]",
        className
      )}
      ref={ref}
      {...props}
    />
  </div>
))
NavigationMenuViewport.displayName =
  NavigationMenuPrimitive.Viewport.displayName

const NavigationMenuIndicator = React.forwardRef<
  React.ElementRef<typeof NavigationMenuPrimitive.Indicator>,
  React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Indicator>
>(({ className, ...props }, ref) => (
  <NavigationMenuPrimitive.Indicator
    ref={ref}
    className={cn(
      "top-full z-[1] flex h-1.5 items-end justify-center overflow-hidden data-[state=visible]:animate-in data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:fade-in",
      className
    )}
    {...props}
  >
    <div className="relative top-[60%] h-2 w-2 rotate-45 rounded-tl-sm bg-border shadow-md" />
  </NavigationMenuPrimitive.Indicator>
))
NavigationMenuIndicator.displayName =
  NavigationMenuPrimitive.Indicator.displayName

export {
  navigationMenuTriggerStyle,
  NavigationMenu,
  NavigationMenuList,
  NavigationMenuItem,
  NavigationMenuContent,
  NavigationMenuTrigger,
  NavigationMenuLink,
  NavigationMenuIndicator,
  NavigationMenuViewport,
}
[V0_FILE]typescriptreact:file="components/ui/pagination.tsx"
import * as React from "react"
import { ChevronLeft, ChevronRight, MoreHorizontal } from "lucide-react"

import { cn } from "@/lib/utils"
import { ButtonProps, buttonVariants } from "@/components/ui/button"

const Pagination = ({ className, ...props }: React.ComponentProps<"nav">) => (
  <nav
    role="navigation"
    aria-label="pagination"
    className={cn("mx-auto flex w-full justify-center", className)}
    {...props}
  />
)
Pagination.displayName = "Pagination"

const PaginationContent = React.forwardRef<
  HTMLUListElement,
  React.ComponentProps<"ul">
>(({ className, ...props }, ref) => (
  <ul
    ref={ref}
    className={cn("flex flex-row items-center gap-1", className)}
    {...props}
  />
))
PaginationContent.displayName = "PaginationContent"

const PaginationItem = React.forwardRef<
  HTMLLIElement,
  React.ComponentProps<"li">
>(({ className, ...props }, ref) => (
  <li ref={ref} className={cn("", className)} {...props} />
))
PaginationItem.displayName = "PaginationItem"

type PaginationLinkProps = {
  isActive?: boolean
} & Pick<ButtonProps, "size"> &
  React.ComponentProps<"a">

const PaginationLink = ({
  className,
  isActive,
  size = "icon",
  ...props
}: PaginationLinkProps) => (
  <a
    aria-current={isActive ? "page" : undefined}
    className={cn(
      buttonVariants({
        variant: isActive ? "outline" : "ghost",
        size,
      }),
      className
    )}
    {...props}
  />
)
PaginationLink.displayName = "PaginationLink"

const PaginationPrevious = ({
  className,
  ...props
}: React.ComponentProps<typeof PaginationLink>) => (
  <PaginationLink
    aria-label="Go to previous page"
    size="default"
    className={cn("gap-1 pl-2.5", className)}
    {...props}
  >
    <ChevronLeft className="h-4 w-4" />
    <span>Previous</span>
  </PaginationLink>
)
PaginationPrevious.displayName = "PaginationPrevious"

const PaginationNext = ({
  className,
  ...props
}: React.ComponentProps<typeof PaginationLink>) => (
  <PaginationLink
    aria-label="Go to next page"
    size="default"
    className={cn("gap-1 pr-2.5", className)}
    {...props}
  >
    <span>Next</span>
    <ChevronRight className="h-4 w-4" />
  </PaginationLink>
)
PaginationNext.displayName = "PaginationNext"

const PaginationEllipsis = ({
  className,
  ...props
}: React.ComponentProps<"span">) => (
  <span
    aria-hidden
    className={cn("flex h-9 w-9 items-center justify-center", className)}
    {...props}
  >
    <MoreHorizontal className="h-4 w-4" />
    <span className="sr-only">More pages</span>
  </span>
)
PaginationEllipsis.displayName = "PaginationEllipsis"

export {
  Pagination,
  PaginationContent,
  PaginationEllipsis,
  PaginationItem,
  PaginationLink,
  PaginationNext,
  PaginationPrevious,
}
[V0_FILE]typescriptreact:file="components/ui/popover.tsx"
"use client"

import * as React from "react"
import * as PopoverPrimitive from "@radix-ui/react-popover"

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

const Popover = PopoverPrimitive.Root

const PopoverTrigger = PopoverPrimitive.Trigger

const PopoverContent = React.forwardRef<
  React.ElementRef<typeof PopoverPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content>
>(({ className, align = "center", sideOffset = 4, ...props }, ref) => (
  <PopoverPrimitive.Portal>
    <PopoverPrimitive.Content
      ref={ref}
      align={align}
      sideOffset={sideOffset}
      className={cn(
        "z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
        className
      )}
      {...props}
    />
  </PopoverPrimitive.Portal>
))
PopoverContent.displayName = PopoverPrimitive.Content.displayName

export { Popover, PopoverTrigger, PopoverContent }
[V0_FILE]typescriptreact:file="components/ui/progress.tsx"
"use client"

import * as React from "react"
import * as ProgressPrimitive from "@radix-ui/react-progress"

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

const Progress = React.forwardRef<
  React.ElementRef<typeof ProgressPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>
>(({ className, value, ...props }, ref) => (
  <ProgressPrimitive.Root
    ref={ref}
    className={cn(
      "relative h-4 w-full overflow-hidden rounded-full bg-secondary",
      className
    )}
    {...props}
  >
    <ProgressPrimitive.Indicator
      className="h-full w-full flex-1 bg-primary transition-all"
      style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
    />
  </ProgressPrimitive.Root>
))
Progress.displayName = ProgressPrimitive.Root.displayName

export { Progress }
[V0_FILE]typescriptreact:file="components/ui/radio-group.tsx"
"use client"

import * as React from "react"
import * as RadioGroupPrimitive from "@radix-ui/react-radio-group"
import { Circle } from "lucide-react"

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

const RadioGroup = React.forwardRef<
  React.ElementRef<typeof RadioGroupPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root>
>(({ className, ...props }, ref) => {
  return (
    <RadioGroupPrimitive.Root
      className={cn("grid gap-2", className)}
      {...props}
      ref={ref}
    />
  )
})
RadioGroup.displayName = RadioGroupPrimitive.Root.displayName

const RadioGroupItem = React.forwardRef<
  React.ElementRef<typeof RadioGroupPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>
>(({ className, ...props }, ref) => {
  return (
    <RadioGroupPrimitive.Item
      ref={ref}
      className={cn(
        "aspect-square h-4 w-4 rounded-full border border-primary text-primary ring-offset-background focus:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
        className
      )}
      {...props}
    >
      <RadioGroupPrimitive.Indicator className="flex items-center justify-center">
        <Circle className="h-2.5 w-2.5 fill-current text-current" />
      </RadioGroupPrimitive.Indicator>
    </RadioGroupPrimitive.Item>
  )
})
RadioGroupItem.displayName = RadioGroupPrimitive.Item.displayName

export { RadioGroup, RadioGroupItem }
[V0_FILE]typescriptreact:file="components/ui/resizable.tsx"
"use client"

import { GripVertical } from "lucide-react"
import * as ResizablePrimitive from "react-resizable-panels"

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

const ResizablePanelGroup = ({
  className,
  ...props
}: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => (
  <ResizablePrimitive.PanelGroup
    className={cn(
      "flex h-full w-full data-[panel-group-direction=vertical]:flex-col",
      className
    )}
    {...props}
  />
)

const ResizablePanel = ResizablePrimitive.Panel

const ResizableHandle = ({
  withHandle,
  className,
  ...props
}: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
  withHandle?: boolean
}) => (
  <ResizablePrimitive.PanelResizeHandle
    className={cn(
      "relative flex w-px items-center justify-center bg-border after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring focus-visible:ring-offset-1 data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:-translate-y-1/2 data-[panel-group-direction=vertical]:after:translate-x-0 [&[data-panel-group-direction=vertical]>div]:rotate-90",
      className
    )}
    {...props}
  >
    {withHandle && (
      <div className="z-10 flex h-4 w-3 items-center justify-center rounded-sm border bg-border">
        <GripVertical className="h-2.5 w-2.5" />
      </div>
    )}
  </ResizablePrimitive.PanelResizeHandle>
)

export { ResizablePanelGroup, ResizablePanel, ResizableHandle }
[V0_FILE]typescriptreact:file="components/ui/scroll-area.tsx"
"use client"

import * as React from "react"
import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area"

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

const ScrollArea = React.forwardRef<
  React.ElementRef<typeof ScrollAreaPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root>
>(({ className, children, ...props }, ref) => (
  <ScrollAreaPrimitive.Root
    ref={ref}
    className={cn("relative overflow-hidden", className)}
    {...props}
  >
    <ScrollAreaPrimitive.Viewport className="h-full w-full rounded-[inherit]">
      {children}
    </ScrollAreaPrimitive.Viewport>
    <ScrollBar />
    <ScrollAreaPrimitive.Corner />
  </ScrollAreaPrimitive.Root>
))
ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName

const ScrollBar = React.forwardRef<
  React.ElementRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>,
  React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>
>(({ className, orientation = "vertical", ...props }, ref) => (
  <ScrollAreaPrimitive.ScrollAreaScrollbar
    ref={ref}
    orientation={orientation}
    className={cn(
      "flex touch-none select-none transition-colors",
      orientation === "vertical" &&
        "h-full w-2.5 border-l border-l-transparent p-[1px]",
      orientation === "horizontal" &&
        "h-2.5 flex-col border-t border-t-transparent p-[1px]",
      className
    )}
    {...props}
  >
    <ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-border" />
  </ScrollAreaPrimitive.ScrollAreaScrollbar>
))
ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName

export { ScrollArea, ScrollBar }
[V0_FILE]typescriptreact:file="components/ui/select.tsx"
"use client"

import * as React from "react"
import * as SelectPrimitive from "@radix-ui/react-select"
import { Check, ChevronDown, ChevronUp } from "lucide-react"

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

const Select = SelectPrimitive.Root

const SelectGroup = SelectPrimitive.Group

const SelectValue = SelectPrimitive.Value

const SelectTrigger = React.forwardRef<
  React.ElementRef<typeof SelectPrimitive.Trigger>,
  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>
>(({ className, children, ...props }, ref) => (
  <SelectPrimitive.Trigger
    ref={ref}
    className={cn(
      "flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
      className
    )}
    {...props}
  >
    {children}
    <SelectPrimitive.Icon asChild>
      <ChevronDown className="h-4 w-4 opacity-50" />
    </SelectPrimitive.Icon>
  </SelectPrimitive.Trigger>
))
SelectTrigger.displayName = SelectPrimitive.Trigger.displayName

const SelectScrollUpButton = React.forwardRef<
  React.ElementRef<typeof SelectPrimitive.ScrollUpButton>,
  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>
>(({ className, ...props }, ref) => (
  <SelectPrimitive.ScrollUpButton
    ref={ref}
    className={cn(
      "flex cursor-default items-center justify-center py-1",
      className
    )}
    {...props}
  >
    <ChevronUp className="h-4 w-4" />
  </SelectPrimitive.ScrollUpButton>
))
SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName

const SelectScrollDownButton = React.forwardRef<
  React.ElementRef<typeof SelectPrimitive.ScrollDownButton>,
  React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>
>(({ className, ...props }, ref) => (
  <SelectPrimitive.ScrollDownButton
    ref={ref}
    className={cn(
      "flex cursor-default items-center justify-center py-1",
      className
    )}
    {...props}
  >
    <ChevronDown className="h-4 w-4" />
  </SelectPrimitive.ScrollDownButton>
))
SelectScrollDownButton.displayName =
  SelectPrimitive.ScrollDownButton.displayName

const SelectContent = React.forwardRef<
  React.ElementRef<typeof SelectPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>
>(({ className, children, position = "popper", ...props }, ref) => (
  <SelectPrimitive.Portal>
    <SelectPrimitive.Content
      ref={ref}
      className={cn(
        "relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
        position === "popper" &&
          "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
        className
      )}
      position={position}
      {...props}
    >
      <SelectScrollUpButton />
      <SelectPrimitive.Viewport
        className={cn(
          "p-1",
          position === "popper" &&
            "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
        )}
      >
        {children}
      </SelectPrimitive.Viewport>
      <SelectScrollDownButton />
    </SelectPrimitive.Content>
  </SelectPrimitive.Portal>
))
SelectContent.displayName = SelectPrimitive.Content.displayName

const SelectLabel = React.forwardRef<
  React.ElementRef<typeof SelectPrimitive.Label>,
  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Label>
>(({ className, ...props }, ref) => (
  <SelectPrimitive.Label
    ref={ref}
    className={cn("py-1.5 pl-8 pr-2 text-sm font-semibold", className)}
    {...props}
  />
))
SelectLabel.displayName = SelectPrimitive.Label.displayName

const SelectItem = React.forwardRef<
  React.ElementRef<typeof SelectPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item>
>(({ className, children, ...props }, ref) => (
  <SelectPrimitive.Item
    ref={ref}
    className={cn(
      "relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
      className
    )}
    {...props}
  >
    <span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
      <SelectPrimitive.ItemIndicator>
        <Check className="h-4 w-4" />
      </SelectPrimitive.ItemIndicator>
    </span>

<SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
  </SelectPrimitive.Item>
))
SelectItem.displayName = SelectPrimitive.Item.displayName

const SelectSeparator = React.forwardRef<
  React.ElementRef<typeof SelectPrimitive.Separator>,
  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>
>(({ className, ...props }, ref) => (
  <SelectPrimitive.Separator
    ref={ref}
    className={cn("-mx-1 my-1 h-px bg-muted", className)}
    {...props}
  />
))
SelectSeparator.displayName = SelectPrimitive.Separator.displayName

export {
  Select,
  SelectGroup,
  SelectValue,
  SelectTrigger,
  SelectContent,
  SelectLabel,
  SelectItem,
  SelectSeparator,
  SelectScrollUpButton,
  SelectScrollDownButton,
}
[V0_FILE]typescriptreact:file="components/ui/separator.tsx"
"use client"

import * as React from "react"
import * as SeparatorPrimitive from "@radix-ui/react-separator"

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

const Separator = React.forwardRef<
  React.ElementRef<typeof SeparatorPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>
>(
  (
    { className, orientation = "horizontal", decorative = true, ...props },
    ref
  ) => (
    <SeparatorPrimitive.Root
      ref={ref}
      decorative={decorative}
      orientation={orientation}
      className={cn(
        "shrink-0 bg-border",
        orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]",
        className
      )}
      {...props}
    />
  )
)
Separator.displayName = SeparatorPrimitive.Root.displayName

export { Separator }
[V0_FILE]typescriptreact:file="components/ui/sheet.tsx"
"use client"

import * as React from "react"
import * as SheetPrimitive from "@radix-ui/react-dialog"
import { cva, type VariantProps } from "class-variance-authority"
import { X } from "lucide-react"

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

const Sheet = SheetPrimitive.Root

const SheetTrigger = SheetPrimitive.Trigger

const SheetClose = SheetPrimitive.Close

const SheetPortal = SheetPrimitive.Portal

const SheetOverlay = React.forwardRef<
  React.ElementRef<typeof SheetPrimitive.Overlay>,
  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Overlay>
>(({ className, ...props }, ref) => (
  <SheetPrimitive.Overlay
    className={cn(
      "fixed inset-0 z-50 bg-black/80  data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
      className
    )}
    {...props}
    ref={ref}
  />
))
SheetOverlay.displayName = SheetPrimitive.Overlay.displayName

const sheetVariants = cva(
  "fixed z-50 gap-4 bg-background p-6 shadow-lg transition ease-in-out data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:duration-300 data-[state=open]:duration-500",
  {
    variants: {
      side: {
        top: "inset-x-0 top-0 border-b data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top",
        bottom:
          "inset-x-0 bottom-0 border-t data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom",
        left: "inset-y-0 left-0 h-full w-3/4 border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left sm:max-w-sm",
        right:
          "inset-y-0 right-0 h-full w-3/4  border-l data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right sm:max-w-sm",
      },
    },
    defaultVariants: {
      side: "right",
    },
  }
)

interface SheetContentProps
  extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>,
    VariantProps<typeof sheetVariants> {}

const SheetContent = React.forwardRef<
  React.ElementRef<typeof SheetPrimitive.Content>,
  SheetContentProps
>(({ side = "right", className, children, ...props }, ref) => (
  <SheetPortal>
    <SheetOverlay />
    <SheetPrimitive.Content
      ref={ref}
      className={cn(sheetVariants({ side }), className)}
      {...props}
    >
      {children}
      <SheetPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary">
        <X className="h-4 w-4" />
        <span className="sr-only">Close</span>
      </SheetPrimitive.Close>
    </SheetPrimitive.Content>
  </SheetPortal>
))
SheetContent.displayName = SheetPrimitive.Content.displayName

const SheetHeader = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn(
      "flex flex-col space-y-2 text-center sm:text-left",
      className
    )}
    {...props}
  />
)
SheetHeader.displayName = "SheetHeader"

const SheetFooter = ({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) => (
  <div
    className={cn(
      "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
      className
    )}
    {...props}
  />
)
SheetFooter.displayName = "SheetFooter"

const SheetTitle = React.forwardRef<
  React.ElementRef<typeof SheetPrimitive.Title>,
  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Title>
>(({ className, ...props }, ref) => (
  <SheetPrimitive.Title
    ref={ref}
    className={cn("text-lg font-semibold text-foreground", className)}
    {...props}
  />
))
SheetTitle.displayName = SheetPrimitive.Title.displayName

const SheetDescription = React.forwardRef<
  React.ElementRef<typeof SheetPrimitive.Description>,
  React.ComponentPropsWithoutRef<typeof SheetPrimitive.Description>
>(({ className, ...props }, ref) => (
  <SheetPrimitive.Description
    ref={ref}
    className={cn("text-sm text-muted-foreground", className)}
    {...props}
  />
))
SheetDescription.displayName = SheetPrimitive.Description.displayName

export {
  Sheet,
  SheetPortal,
  SheetOverlay,
  SheetTrigger,
  SheetClose,
  SheetContent,
  SheetHeader,
  SheetFooter,
  SheetTitle,
  SheetDescription,
}
[V0_FILE]typescriptreact:file="components/ui/sidebar.tsx"
"use client"

import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { VariantProps, cva } from "class-variance-authority"
import { PanelLeft } from "lucide-react"

import { useIsMobile } from "@/hooks/use-mobile"
import { cn } from "@/lib/utils"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Separator } from "@/components/ui/separator"
import { Sheet, SheetContent } from "@/components/ui/sheet"
import { Skeleton } from "@/components/ui/skeleton"
import {
  Tooltip,
  TooltipContent,
  TooltipProvider,
  TooltipTrigger,
} from "@/components/ui/tooltip"

const SIDEBAR_COOKIE_NAME = "sidebar:state"
const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7
const SIDEBAR_WIDTH = "16rem"
const SIDEBAR_WIDTH_MOBILE = "18rem"
const SIDEBAR_WIDTH_ICON = "3rem"
const SIDEBAR_KEYBOARD_SHORTCUT = "b"

type SidebarContext = {
  state: "expanded" | "collapsed"
  open: boolean
  setOpen: (open: boolean) => void
  openMobile: boolean
  setOpenMobile: (open: boolean) => void
  isMobile: boolean
  toggleSidebar: () => void
}

const SidebarContext = React.createContext<SidebarContext | null>(null)

function useSidebar() {
  const context = React.useContext(SidebarContext)
  if (!context) {
    throw new Error("useSidebar must be used within a SidebarProvider.")
  }

return context
}

const SidebarProvider = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div"> & {
    defaultOpen?: boolean
    open?: boolean
    onOpenChange?: (open: boolean) => void
  }
>(
  (
    {
      defaultOpen = true,
      open: openProp,
      onOpenChange: setOpenProp,
      className,
      style,
      children,
      ...props
    },
    ref
  ) => {
    const isMobile = useIsMobile()
    const [openMobile, setOpenMobile] = React.useState(false)

// This is the internal state of the sidebar.
    // We use openProp and setOpenProp for control from outside the component.
    const [_open, _setOpen] = React.useState(defaultOpen)
    const open = openProp ?? _open
    const setOpen = React.useCallback(
      (value: boolean | ((value: boolean) => boolean)) => {
        const openState = typeof value === "function" ? value(open) : value
        if (setOpenProp) {
          setOpenProp(openState)
        } else {
          _setOpen(openState)
        }

// This sets the cookie to keep the sidebar state.
        document.cookie = `${SIDEBAR_COOKIE_NAME}=${openState}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`
      },
      [setOpenProp, open]
    )

// Helper to toggle the sidebar.
    const toggleSidebar = React.useCallback(() => {
      return isMobile
        ? setOpenMobile((open) => !open)
        : setOpen((open) => !open)
    }, [isMobile, setOpen, setOpenMobile])

// Adds a keyboard shortcut to toggle the sidebar.
    React.useEffect(() => {
      const handleKeyDown = (event: KeyboardEvent) => {
        if (
          event.key === SIDEBAR_KEYBOARD_SHORTCUT &&
          (event.metaKey || event.ctrlKey)
        ) {
          event.preventDefault()
          toggleSidebar()
        }
      }

window.addEventListener("keydown", handleKeyDown)
      return () => window.removeEventListener("keydown", handleKeyDown)
    }, [toggleSidebar])

// We add a state so that we can do data-state="expanded" or "collapsed".
    // This makes it easier to style the sidebar with Tailwind classes.
    const state = open ? "expanded" : "collapsed"

const contextValue = React.useMemo<SidebarContext>(
      () => ({
        state,
        open,
        setOpen,
        isMobile,
        openMobile,
        setOpenMobile,
        toggleSidebar,
      }),
      [state, open, setOpen, isMobile, openMobile, setOpenMobile, toggleSidebar]
    )

return (
      <SidebarContext.Provider value={contextValue}>
        <TooltipProvider delayDuration={0}>
          <div
            style={
              {
                "--sidebar-width": SIDEBAR_WIDTH,
                "--sidebar-width-icon": SIDEBAR_WIDTH_ICON,
                ...style,
              } as React.CSSProperties
            }
            className={cn(
              "group/sidebar-wrapper flex min-h-svh w-full has-[[data-variant=inset]]:bg-sidebar",
              className
            )}
            ref={ref}
            {...props}
          >
            {children}
          </div>
        </TooltipProvider>
      </SidebarContext.Provider>
    )
  }
)
SidebarProvider.displayName = "SidebarProvider"

const Sidebar = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div"> & {
    side?: "left" | "right"
    variant?: "sidebar" | "floating" | "inset"
    collapsible?: "offcanvas" | "icon" | "none"
  }
>(
  (
    {
      side = "left",
      variant = "sidebar",
      collapsible = "offcanvas",
      className,
      children,
      ...props
    },
    ref
  ) => {
    const { isMobile, state, openMobile, setOpenMobile } = useSidebar()

if (collapsible === "none") {
      return (
        <div
          className={cn(
            "flex h-full w-[--sidebar-width] flex-col bg-sidebar text-sidebar-foreground",
            className
          )}
          ref={ref}
          {...props}
        >
          {children}
        </div>
      )
    }

if (isMobile) {
      return (
        <Sheet open={openMobile} onOpenChange={setOpenMobile} {...props}>
          <SheetContent
            data-sidebar="sidebar"
            data-mobile="true"
            className="w-[--sidebar-width] bg-sidebar p-0 text-sidebar-foreground [&>button]:hidden"
            style={
              {
                "--sidebar-width": SIDEBAR_WIDTH_MOBILE,
              } as React.CSSProperties
            }
            side={side}
          >
            <div className="flex h-full w-full flex-col">{children}</div>
          </SheetContent>
        </Sheet>
      )
    }

return (
      <div
        ref={ref}
        className="group peer hidden md:block text-sidebar-foreground"
        data-state={state}
        data-collapsible={state === "collapsed" ? collapsible : ""}
        data-variant={variant}
        data-side={side}
      >
        {/* This is what handles the sidebar gap on desktop */}
        <div
          className={cn(
            "duration-200 relative h-svh w-[--sidebar-width] bg-transparent transition-[width] ease-linear",
            "group-data-[collapsible=offcanvas]:w-0",
            "group-data-[side=right]:rotate-180",
            variant === "floating" || variant === "inset"
              ? "group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)_+_theme(spacing.4))]"
              : "group-data-[collapsible=icon]:w-[--sidebar-width-icon]"
          )}
        />
        <div
          className={cn(
            "duration-200 fixed inset-y-0 z-10 hidden h-svh w-[--sidebar-width] transition-[left,right,width] ease-linear md:flex",
            side === "left"
              ? "left-0 group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)]"
              : "right-0 group-data-[collapsible=offcanvas]:right-[calc(var(--sidebar-width)*-1)]",
            // Adjust the padding for floating and inset variants.
            variant === "floating" || variant === "inset"
              ? "p-2 group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)_+_theme(spacing.4)_+2px)]"
              : "group-data-[collapsible=icon]:w-[--sidebar-width-icon] group-data-[side=left]:border-r group-data-[side=right]:border-l",
            className
          )}
          {...props}
        >
          <div
            data-sidebar="sidebar"
            className="flex h-full w-full flex-col bg-sidebar group-data-[variant=floating]:rounded-lg group-data-[variant=floating]:border group-data-[variant=floating]:border-sidebar-border group-data-[variant=floating]:shadow"
          >
            {children}
          </div>
        </div>
      </div>
    )
  }
)
Sidebar.displayName = "Sidebar"

const SidebarTrigger = React.forwardRef<
  React.ElementRef<typeof Button>,
  React.ComponentProps<typeof Button>
>(({ className, onClick, ...props }, ref) => {
  const { toggleSidebar } = useSidebar()

return (
    <Button
      ref={ref}
      data-sidebar="trigger"
      variant="ghost"
      size="icon"
      className={cn("h-7 w-7", className)}
      onClick={(event) => {
        onClick?.(event)
        toggleSidebar()
      }}
      {...props}
    >
      <PanelLeft />
      <span className="sr-only">Toggle Sidebar</span>
    </Button>
  )
})
SidebarTrigger.displayName = "SidebarTrigger"

const SidebarRail = React.forwardRef<
  HTMLButtonElement,
  React.ComponentProps<"button">
>(({ className, ...props }, ref) => {
  const { toggleSidebar } = useSidebar()

return (
    <button
      ref={ref}
      data-sidebar="rail"
      aria-label="Toggle Sidebar"
      tabIndex={-1}
      onClick={toggleSidebar}
      title="Toggle Sidebar"
      className={cn(
        "absolute inset-y-0 z-20 hidden w-4 -translate-x-1/2 transition-all ease-linear after:absolute after:inset-y-0 after:left-1/2 after:w-[2px] hover:after:bg-sidebar-border group-data-[side=left]:-right-4 group-data-[side=right]:left-0 sm:flex",
        "[[data-side=left]_&]:cursor-w-resize [[data-side=right]_&]:cursor-e-resize",
        "[[data-side=left][data-state=collapsed]_&]:cursor-e-resize [[data-side=right][data-state=collapsed]_&]:cursor-w-resize",
        "group-data-[collapsible=offcanvas]:translate-x-0 group-data-[collapsible=offcanvas]:after:left-full group-data-[collapsible=offcanvas]:hover:bg-sidebar",
        "[[data-side=left][data-collapsible=offcanvas]_&]:-right-2",
        "[[data-side=right][data-collapsible=offcanvas]_&]:-left-2",
        className
      )}
      {...props}
    />
  )
})
SidebarRail.displayName = "SidebarRail"

const SidebarInset = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"main">
>(({ className, ...props }, ref) => {
  return (
    <main
      ref={ref}
      className={cn(
        "relative flex min-h-svh flex-1 flex-col bg-background",
        "peer-data-[variant=inset]:min-h-[calc(100svh-theme(spacing.4))] md:peer-data-[variant=inset]:m-2 md:peer-data-[state=collapsed]:peer-data-[variant=inset]:ml-2 md:peer-data-[variant=inset]:ml-0 md:peer-data-[variant=inset]:rounded-xl md:peer-data-[variant=inset]:shadow",
        className
      )}
      {...props}
    />
  )
})
SidebarInset.displayName = "SidebarInset"

const SidebarInput = React.forwardRef<
  React.ElementRef<typeof Input>,
  React.ComponentProps<typeof Input>
>(({ className, ...props }, ref) => {
  return (
    <Input
      ref={ref}
      data-sidebar="input"
      className={cn(
        "h-8 w-full bg-background shadow-none focus-visible:ring-2 focus-visible:ring-sidebar-ring",
        className
      )}
      {...props}
    />
  )
})
SidebarInput.displayName = "SidebarInput"

const SidebarHeader = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
  return (
    <div
      ref={ref}
      data-sidebar="header"
      className={cn("flex flex-col gap-2 p-2", className)}
      {...props}
    />
  )
})
SidebarHeader.displayName = "SidebarHeader"

const SidebarFooter = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
  return (
    <div
      ref={ref}
      data-sidebar="footer"
      className={cn("flex flex-col gap-2 p-2", className)}
      {...props}
    />
  )
})
SidebarFooter.displayName = "SidebarFooter"

const SidebarSeparator = React.forwardRef<
  React.ElementRef<typeof Separator>,
  React.ComponentProps<typeof Separator>
>(({ className, ...props }, ref) => {
  return (
    <Separator
      ref={ref}
      data-sidebar="separator"
      className={cn("mx-2 w-auto bg-sidebar-border", className)}
      {...props}
    />
  )
})
SidebarSeparator.displayName = "SidebarSeparator"

const SidebarContent = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
  return (
    <div
      ref={ref}
      data-sidebar="content"
      className={cn(
        "flex min-h-0 flex-1 flex-col gap-2 overflow-auto group-data-[collapsible=icon]:overflow-hidden",
        className
      )}
      {...props}
    />
  )
})
SidebarContent.displayName = "SidebarContent"

const SidebarGroup = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
  return (
    <div
      ref={ref}
      data-sidebar="group"
      className={cn("relative flex w-full min-w-0 flex-col p-2", className)}
      {...props}
    />
  )
})
SidebarGroup.displayName = "SidebarGroup"

const SidebarGroupLabel = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div"> & { asChild?: boolean }
>(({ className, asChild = false, ...props }, ref) => {
  const Comp = asChild ? Slot : "div"

return (
    <Comp
      ref={ref}
      data-sidebar="group-label"
      className={cn(
        "duration-200 flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium text-sidebar-foreground/70 outline-none ring-sidebar-ring transition-[margin,opa] ease-linear focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
        "group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0",
        className
      )}
      {...props}
    />
  )
})
SidebarGroupLabel.displayName = "SidebarGroupLabel"

const SidebarGroupAction = React.forwardRef<
  HTMLButtonElement,
  React.ComponentProps<"button"> & { asChild?: boolean }
>(({ className, asChild = false, ...props }, ref) => {
  const Comp = asChild ? Slot : "button"

return (
    <Comp
      ref={ref}
      data-sidebar="group-action"
      className={cn(
        "absolute right-3 top-3.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-none ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
        // Increases the hit area of the button on mobile.
        "after:absolute after:-inset-2 after:md:hidden",
        "group-data-[collapsible=icon]:hidden",
        className
      )}
      {...props}
    />
  )
})
SidebarGroupAction.displayName = "SidebarGroupAction"

const SidebarGroupContent = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div">
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    data-sidebar="group-content"
    className={cn("w-full text-sm", className)}
    {...props}
  />
))
SidebarGroupContent.displayName = "SidebarGroupContent"

const SidebarMenu = React.forwardRef<
  HTMLUListElement,
  React.ComponentProps<"ul">
>(({ className, ...props }, ref) => (
  <ul
    ref={ref}
    data-sidebar="menu"
    className={cn("flex w-full min-w-0 flex-col gap-1", className)}
    {...props}
  />
))
SidebarMenu.displayName = "SidebarMenu"

const SidebarMenuItem = React.forwardRef<
  HTMLLIElement,
  React.ComponentProps<"li">
>(({ className, ...props }, ref) => (
  <li
    ref={ref}
    data-sidebar="menu-item"
    className={cn("group/menu-item relative", className)}
    {...props}
  />
))
SidebarMenuItem.displayName = "SidebarMenuItem"

const sidebarMenuButtonVariants = cva(
  "peer/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-none ring-sidebar-ring transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 group-has-[[data-sidebar=menu-action]]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground group-data-[collapsible=icon]:!size-8 group-data-[collapsible=icon]:!p-2 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
  {
    variants: {
      variant: {
        default: "hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
        outline:
          "bg-background shadow-[0_0_0_1px_hsl(var(--sidebar-border))] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground hover:shadow-[0_0_0_1px_hsl(var(--sidebar-accent))]",
      },
      size: {
        default: "h-8 text-sm",
        sm: "h-7 text-xs",
        lg: "h-12 text-sm group-data-[collapsible=icon]:!p-0",
      },
    },
    defaultVariants: {
      variant: "default",
      size: "default",
    },
  }
)

const SidebarMenuButton = React.forwardRef<
  HTMLButtonElement,
  React.ComponentProps<"button"> & {
    asChild?: boolean
    isActive?: boolean
    tooltip?: string | React.ComponentProps<typeof TooltipContent>
  } & VariantProps<typeof sidebarMenuButtonVariants>
>(
  (
    {
      asChild = false,
      isActive = false,
      variant = "default",
      size = "default",
      tooltip,
      className,
      ...props
    },
    ref
  ) => {
    const Comp = asChild ? Slot : "button"
    const { isMobile, state } = useSidebar()

const button = (
      <Comp
        ref={ref}
        data-sidebar="menu-button"
        data-size={size}
        data-active={isActive}
        className={cn(sidebarMenuButtonVariants({ variant, size }), className)}
        {...props}
      />
    )

if (!tooltip) {
      return button
    }

if (typeof tooltip === "string") {
      tooltip = {
        children: tooltip,
      }
    }

return (
      <Tooltip>
        <TooltipTrigger asChild>{button}</TooltipTrigger>
        <TooltipContent
          side="right"
          align="center"
          hidden={state !== "collapsed" || isMobile}
          {...tooltip}
        />
      </Tooltip>
    )
  }
)
SidebarMenuButton.displayName = "SidebarMenuButton"

const SidebarMenuAction = React.forwardRef<
  HTMLButtonElement,
  React.ComponentProps<"button"> & {
    asChild?: boolean
    showOnHover?: boolean
  }
>(({ className, asChild = false, showOnHover = false, ...props }, ref) => {
  const Comp = asChild ? Slot : "button"

return (
    <Comp
      ref={ref}
      data-sidebar="menu-action"
      className={cn(
        "absolute right-1 top-1.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-none ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 peer-hover/menu-button:text-sidebar-accent-foreground [&>svg]:size-4 [&>svg]:shrink-0",
        // Increases the hit area of the button on mobile.
        "after:absolute after:-inset-2 after:md:hidden",
        "peer-data-[size=sm]/menu-button:top-1",
        "peer-data-[size=default]/menu-button:top-1.5",
        "peer-data-[size=lg]/menu-button:top-2.5",
        "group-data-[collapsible=icon]:hidden",
        showOnHover &&
          "group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 data-[state=open]:opacity-100 peer-data-[active=true]/menu-button:text-sidebar-accent-foreground md:opacity-0",
        className
      )}
      {...props}
    />
  )
})
SidebarMenuAction.displayName = "SidebarMenuAction"

const SidebarMenuBadge = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div">
>(({ className, ...props }, ref) => (
  <div
    ref={ref}
    data-sidebar="menu-badge"
    className={cn(
      "absolute right-1 flex h-5 min-w-5 items-center justify-center rounded-md px-1 text-xs font-medium tabular-nums text-sidebar-foreground select-none pointer-events-none",
      "peer-hover/menu-button:text-sidebar-accent-foreground peer-data-[active=true]/menu-button:text-sidebar-accent-foreground",
      "peer-data-[size=sm]/menu-button:top-1",
      "peer-data-[size=default]/menu-button:top-1.5",
      "peer-data-[size=lg]/menu-button:top-2.5",
      "group-data-[collapsible=icon]:hidden",
      className
    )}
    {...props}
  />
))
SidebarMenuBadge.displayName = "SidebarMenuBadge"

const SidebarMenuSkeleton = React.forwardRef<
  HTMLDivElement,
  React.ComponentProps<"div"> & {
    showIcon?: boolean
  }
>(({ className, showIcon = false, ...props }, ref) => {
  // Random width between 50 to 90%.
  const width = React.useMemo(() => {
    return `${Math.floor(Math.random() * 40) + 50}%`
  }, [])

return (
    <div
      ref={ref}
      data-sidebar="menu-skeleton"
      className={cn("rounded-md h-8 flex gap-2 px-2 items-center", className)}
      {...props}
    >
      {showIcon && (
        <Skeleton
          className="size-4 rounded-md"
          data-sidebar="menu-skeleton-icon"
        />
      )}
      <Skeleton
        className="h-4 flex-1 max-w-[--skeleton-width]"
        data-sidebar="menu-skeleton-text"
        style={
          {
            "--skeleton-width": width,
          } as React.CSSProperties
        }
      />
    </div>
  )
})
SidebarMenuSkeleton.displayName = "SidebarMenuSkeleton"

const SidebarMenuSub = React.forwardRef<
  HTMLUListElement,
  React.ComponentProps<"ul">
>(({ className, ...props }, ref) => (
  <ul
    ref={ref}
    data-sidebar="menu-sub"
    className={cn(
      "mx-3.5 flex min-w-0 translate-x-px flex-col gap-1 border-l border-sidebar-border px-2.5 py-0.5",
      "group-data-[collapsible=icon]:hidden",
      className
    )}
    {...props}
  />
))
SidebarMenuSub.displayName = "SidebarMenuSub"

const SidebarMenuSubItem = React.forwardRef<
  HTMLLIElement,
  React.ComponentProps<"li">
>(({ ...props }, ref) => <li ref={ref} {...props} />)
SidebarMenuSubItem.displayName = "SidebarMenuSubItem"

const SidebarMenuSubButton = React.forwardRef<
  HTMLAnchorElement,
  React.ComponentProps<"a"> & {
    asChild?: boolean
    size?: "sm" | "md"
    isActive?: boolean
  }
>(({ asChild = false, size = "md", isActive, className, ...props }, ref) => {
  const Comp = asChild ? Slot : "a"

return (
    <Comp
      ref={ref}
      data-sidebar="menu-sub-button"
      data-size={size}
      data-active={isActive}
      className={cn(
        "flex h-7 min-w-0 -translate-x-px items-center gap-2 overflow-hidden rounded-md px-2 text-sidebar-foreground outline-none ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0 [&>svg]:text-sidebar-accent-foreground",
        "data-[active=true]:bg-sidebar-accent data-[active=true]:text-sidebar-accent-foreground",
        size === "sm" && "text-xs",
        size === "md" && "text-sm",
        "group-data-[collapsible=icon]:hidden",
        className
      )}
      {...props}
    />
  )
})
SidebarMenuSubButton.displayName = "SidebarMenuSubButton"

export {
  Sidebar,
  SidebarContent,
  SidebarFooter,
  SidebarGroup,
  SidebarGroupAction,
  SidebarGroupContent,
  SidebarGroupLabel,
  SidebarHeader,
  SidebarInput,
  SidebarInset,
  SidebarMenu,
  SidebarMenuAction,
  SidebarMenuBadge,
  SidebarMenuButton,
  SidebarMenuItem,
  SidebarMenuSkeleton,
  SidebarMenuSub,
  SidebarMenuSubButton,
  SidebarMenuSubItem,
  SidebarProvider,
  SidebarRail,
  SidebarSeparator,
  SidebarTrigger,
  useSidebar,
}
[V0_FILE]typescriptreact:file="components/ui/skeleton.tsx"
import { cn } from "@/lib/utils"

function Skeleton({
  className,
  ...props
}: React.HTMLAttributes<HTMLDivElement>) {
  return (
    <div
      className={cn("animate-pulse rounded-md bg-muted", className)}
      {...props}
    />
  )
}

export { Skeleton }
[V0_FILE]typescriptreact:file="components/ui/slider.tsx"
"use client"

import * as React from "react"
import * as SliderPrimitive from "@radix-ui/react-slider"

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

const Slider = React.forwardRef<
  React.ElementRef<typeof SliderPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>
>(({ className, ...props }, ref) => (
  <SliderPrimitive.Root
    ref={ref}
    className={cn(
      "relative flex w-full touch-none select-none items-center",
      className
    )}
    {...props}
  >
    <SliderPrimitive.Track className="relative h-2 w-full grow overflow-hidden rounded-full bg-secondary">
      <SliderPrimitive.Range className="absolute h-full bg-primary" />
    </SliderPrimitive.Track>
    <SliderPrimitive.Thumb className="block h-5 w-5 rounded-full border-2 border-primary bg-background ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50" />
  </SliderPrimitive.Root>
))
Slider.displayName = SliderPrimitive.Root.displayName

export { Slider }
[V0_FILE]typescriptreact:file="components/ui/sonner.tsx"
"use client"

import { useTheme } from "next-themes"
import { Toaster as Sonner } from "sonner"

type ToasterProps = React.ComponentProps<typeof Sonner>

const Toaster = ({ ...props }: ToasterProps) => {
  const { theme = "system" } = useTheme()

return (
    <Sonner
      theme={theme as ToasterProps["theme"]}
      className="toaster group"
      toastOptions={{
        classNames: {
          toast:
            "group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg",
          description: "group-[.toast]:text-muted-foreground",
          actionButton:
            "group-[.toast]:bg-primary group-[.toast]:text-primary-foreground",
          cancelButton:
            "group-[.toast]:bg-muted group-[.toast]:text-muted-foreground",
        },
      }}
      {...props}
    />
  )
}

export { Toaster }
[V0_FILE]typescriptreact:file="components/ui/switch.tsx"
"use client"

import * as React from "react"
import * as SwitchPrimitives from "@radix-ui/react-switch"

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

const Switch = React.forwardRef<
  React.ElementRef<typeof SwitchPrimitives.Root>,
  React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>
>(({ className, ...props }, ref) => (
  <SwitchPrimitives.Root
    className={cn(
      "peer inline-flex h-6 w-11 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input",
      className
    )}
    {...props}
    ref={ref}
  >
    <SwitchPrimitives.Thumb
      className={cn(
        "pointer-events-none block h-5 w-5 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-5 data-[state=unchecked]:translate-x-0"
      )}
    />
  </SwitchPrimitives.Root>
))
Switch.displayName = SwitchPrimitives.Root.displayName

export { Switch }
[V0_FILE]typescriptreact:file="components/ui/table.tsx"
import * as React from "react"

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

const Table = React.forwardRef<
  HTMLTableElement,
  React.HTMLAttributes<HTMLTableElement>
>(({ className, ...props }, ref) => (
  <div className="relative w-full overflow-auto">
    <table
      ref={ref}
      className={cn("w-full caption-bottom text-sm", className)}
      {...props}
    />
  </div>
))
Table.displayName = "Table"

const TableHeader = React.forwardRef<
  HTMLTableSectionElement,
  React.HTMLAttributes<HTMLTableSectionElement>
>(({ className, ...props }, ref) => (
  <thead ref={ref} className={cn("[&_tr]:border-b", className)} {...props} />
))
TableHeader.displayName = "TableHeader"

const TableBody = React.forwardRef<
  HTMLTableSectionElement,
  React.HTMLAttributes<HTMLTableSectionElement>
>(({ className, ...props }, ref) => (
  <tbody
    ref={ref}
    className={cn("[&_tr:last-child]:border-0", className)}
    {...props}
  />
))
TableBody.displayName = "TableBody"

const TableFooter = React.forwardRef<
  HTMLTableSectionElement,
  React.HTMLAttributes<HTMLTableSectionElement>
>(({ className, ...props }, ref) => (
  <tfoot
    ref={ref}
    className={cn(
      "border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
      className
    )}
    {...props}
  />
))
TableFooter.displayName = "TableFooter"

const TableRow = React.forwardRef<
  HTMLTableRowElement,
  React.HTMLAttributes<HTMLTableRowElement>
>(({ className, ...props }, ref) => (
  <tr
    ref={ref}
    className={cn(
      "border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted",
      className
    )}
    {...props}
  />
))
TableRow.displayName = "TableRow"

const TableHead = React.forwardRef<
  HTMLTableCellElement,
  React.ThHTMLAttributes<HTMLTableCellElement>
>(({ className, ...props }, ref) => (
  <th
    ref={ref}
    className={cn(
      "h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0",
      className
    )}
    {...props}
  />
))
TableHead.displayName = "TableHead"

const TableCell = React.forwardRef<
  HTMLTableCellElement,
  React.TdHTMLAttributes<HTMLTableCellElement>
>(({ className, ...props }, ref) => (
  <td
    ref={ref}
    className={cn("p-4 align-middle [&:has([role=checkbox])]:pr-0", className)}
    {...props}
  />
))
TableCell.displayName = "TableCell"

const TableCaption = React.forwardRef<
  HTMLTableCaptionElement,
  React.HTMLAttributes<HTMLTableCaptionElement>
>(({ className, ...props }, ref) => (
  <caption
    ref={ref}
    className={cn("mt-4 text-sm text-muted-foreground", className)}
    {...props}
  />
))
TableCaption.displayName = "TableCaption"

export {
  Table,
  TableHeader,
  TableBody,
  TableFooter,
  TableHead,
  TableRow,
  TableCell,
  TableCaption,
}
[V0_FILE]typescriptreact:file="components/ui/tabs.tsx"
"use client"

import * as React from "react"
import * as TabsPrimitive from "@radix-ui/react-tabs"

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

const Tabs = TabsPrimitive.Root

const TabsList = React.forwardRef<
  React.ElementRef<typeof TabsPrimitive.List>,
  React.ComponentPropsWithoutRef<typeof TabsPrimitive.List>
>(({ className, ...props }, ref) => (
  <TabsPrimitive.List
    ref={ref}
    className={cn(
      "inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground",
      className,
    )}
    {...props}
  />
))
TabsList.displayName = TabsPrimitive.List.displayName

const TabsTrigger = React.forwardRef<
  React.ElementRef<typeof TabsPrimitive.Trigger>,
  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>
>(({ className, ...props }, ref) => (
  <TabsPrimitive.Trigger
    ref={ref}
    className={cn(
      "inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow-sm",
      className,
    )}
    {...props}
  />
))
TabsTrigger.displayName = TabsPrimitive.Trigger.displayName

const TabsContent = React.forwardRef<
  React.ElementRef<typeof TabsPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>
>(({ className, ...props }, ref) => (
  <TabsPrimitive.Content
    ref={ref}
    className={cn(
      "mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
      className,
    )}
    {...props}
  />
))
TabsContent.displayName = TabsPrimitive.Content.displayName

export { Tabs, TabsList, TabsTrigger, TabsContent }
[V0_FILE]typescriptreact:file="components/ui/textarea.tsx"
import * as React from "react"

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

export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {}

const Textarea = React.forwardRef<HTMLTextAreaElement, TextareaProps>(({ className, ...props }, ref) => {
  return (
    <textarea
      className={cn(
        "flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
        className,
      )}
      ref={ref}
      {...props}
    />
  )
})
Textarea.displayName = "Textarea"

export { Textarea }
[V0_FILE]typescriptreact:file="components/ui/toast.tsx"
"use client"

import * as React from "react"
import * as ToastPrimitives from "@radix-ui/react-toast"
import { cva, type VariantProps } from "class-variance-authority"
import { X } from "lucide-react"

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

const ToastProvider = ToastPrimitives.Provider

const ToastViewport = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Viewport>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Viewport
    ref={ref}
    className={cn(
      "fixed top-0 z-[100] flex max-h-screen w-full flex-col-reverse p-4 sm:bottom-0 sm:right-0 sm:top-auto sm:flex-col md:max-w-[420px]",
      className
    )}
    {...props}
  />
))
ToastViewport.displayName = ToastPrimitives.Viewport.displayName

const toastVariants = cva(
  "group pointer-events-auto relative flex w-full items-center justify-between space-x-4 overflow-hidden rounded-md border p-6 pr-8 shadow-lg transition-all data-[swipe=cancel]:translate-x-0 data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] data-[swipe=move]:transition-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[swipe=end]:animate-out data-[state=closed]:fade-out-80 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-top-full data-[state=open]:sm:slide-in-from-bottom-full",
  {
    variants: {
      variant: {
        default: "border bg-background text-foreground",
        destructive:
          "destructive group border-destructive bg-destructive text-destructive-foreground",
      },
    },
    defaultVariants: {
      variant: "default",
    },
  }
)

const Toast = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Root>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Root> &
    VariantProps<typeof toastVariants>
>(({ className, variant, ...props }, ref) => {
  return (
    <ToastPrimitives.Root
      ref={ref}
      className={cn(toastVariants({ variant }), className)}
      {...props}
    />
  )
})
Toast.displayName = ToastPrimitives.Root.displayName

const ToastAction = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Action>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Action>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Action
    ref={ref}
    className={cn(
      "inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium ring-offset-background transition-colors hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive",
      className
    )}
    {...props}
  />
))
ToastAction.displayName = ToastPrimitives.Action.displayName

const ToastClose = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Close>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Close>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Close
    ref={ref}
    className={cn(
      "absolute right-2 top-2 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-2 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600",
      className
    )}
    toast-close=""
    {...props}
  >
    <X className="h-4 w-4" />
  </ToastPrimitives.Close>
))
ToastClose.displayName = ToastPrimitives.Close.displayName

const ToastTitle = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Title>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Title>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Title
    ref={ref}
    className={cn("text-sm font-semibold", className)}
    {...props}
  />
))
ToastTitle.displayName = ToastPrimitives.Title.displayName

const ToastDescription = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Description>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Description>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Description
    ref={ref}
    className={cn("text-sm opacity-90", className)}
    {...props}
  />
))
ToastDescription.displayName = ToastPrimitives.Description.displayName

type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>

type ToastActionElement = React.ReactElement<typeof ToastAction>

export {
  type ToastProps,
  type ToastActionElement,
  ToastProvider,
  ToastViewport,
  Toast,
  ToastTitle,
  ToastDescription,
  ToastClose,
  ToastAction,
}
[V0_FILE]typescriptreact:file="components/ui/toaster.tsx"
"use client"

import { useToast } from "@/hooks/use-toast"
import {
  Toast,
  ToastClose,
  ToastDescription,
  ToastProvider,
  ToastTitle,
  ToastViewport,
} from "@/components/ui/toast"

export function Toaster() {
  const { toasts } = useToast()

return (
    <ToastProvider>
      {toasts.map(function ({ id, title, description, action, ...props }) {
        return (
          <Toast key={id} {...props}>
            <div className="grid gap-1">
              {title && <ToastTitle>{title}</ToastTitle>}
              {description && (
                <ToastDescription>{description}</ToastDescription>
              )}
            </div>
            {action}
            <ToastClose />
          </Toast>
        )
      })}
      <ToastViewport />
    </ToastProvider>
  )
}
[V0_FILE]typescriptreact:file="components/ui/toggle-group.tsx"
"use client"

import * as React from "react"
import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group"
import { type VariantProps } from "class-variance-authority"

import { cn } from "@/lib/utils"
import { toggleVariants } from "@/components/ui/toggle"

const ToggleGroupContext = React.createContext<
  VariantProps<typeof toggleVariants>
>({
  size: "default",
  variant: "default",
})

const ToggleGroup = React.forwardRef<
  React.ElementRef<typeof ToggleGroupPrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Root> &
    VariantProps<typeof toggleVariants>
>(({ className, variant, size, children, ...props }, ref) => (
  <ToggleGroupPrimitive.Root
    ref={ref}
    className={cn("flex items-center justify-center gap-1", className)}
    {...props}
  >
    <ToggleGroupContext.Provider value={{ variant, size }}>
      {children}
    </ToggleGroupContext.Provider>
  </ToggleGroupPrimitive.Root>
))

ToggleGroup.displayName = ToggleGroupPrimitive.Root.displayName

const ToggleGroupItem = React.forwardRef<
  React.ElementRef<typeof ToggleGroupPrimitive.Item>,
  React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Item> &
    VariantProps<typeof toggleVariants>
>(({ className, children, variant, size, ...props }, ref) => {
  const context = React.useContext(ToggleGroupContext)

return (
    <ToggleGroupPrimitive.Item
      ref={ref}
      className={cn(
        toggleVariants({
          variant: context.variant || variant,
          size: context.size || size,
        }),
        className
      )}
      {...props}
    >
      {children}
    </ToggleGroupPrimitive.Item>
  )
})

ToggleGroupItem.displayName = ToggleGroupPrimitive.Item.displayName

export { ToggleGroup, ToggleGroupItem }
[V0_FILE]typescriptreact:file="components/ui/toggle.tsx"
"use client"

import * as React from "react"
import * as TogglePrimitive from "@radix-ui/react-toggle"
import { cva, type VariantProps } from "class-variance-authority"

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

const toggleVariants = cva(
  "inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors hover:bg-muted hover:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0 gap-2",
  {
    variants: {
      variant: {
        default: "bg-transparent",
        outline:
          "border border-input bg-transparent hover:bg-accent hover:text-accent-foreground",
      },
      size: {
        default: "h-10 px-3 min-w-10",
        sm: "h-9 px-2.5 min-w-9",
        lg: "h-11 px-5 min-w-11",
      },
    },
    defaultVariants: {
      variant: "default",
      size: "default",
    },
  }
)

const Toggle = React.forwardRef<
  React.ElementRef<typeof TogglePrimitive.Root>,
  React.ComponentPropsWithoutRef<typeof TogglePrimitive.Root> &
    VariantProps<typeof toggleVariants>
>(({ className, variant, size, ...props }, ref) => (
  <TogglePrimitive.Root
    ref={ref}
    className={cn(toggleVariants({ variant, size, className }))}
    {...props}
  />
))

Toggle.displayName = TogglePrimitive.Root.displayName

export { Toggle, toggleVariants }
[V0_FILE]typescriptreact:file="components/ui/tooltip.tsx"
"use client"

import * as React from "react"
import * as TooltipPrimitive from "@radix-ui/react-tooltip"

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

const TooltipProvider = TooltipPrimitive.Provider

const Tooltip = TooltipPrimitive.Root

const TooltipTrigger = TooltipPrimitive.Trigger

const TooltipContent = React.forwardRef<
  React.ElementRef<typeof TooltipPrimitive.Content>,
  React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>
>(({ className, sideOffset = 4, ...props }, ref) => (
  <TooltipPrimitive.Content
    ref={ref}
    sideOffset={sideOffset}
    className={cn(
      "z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
      className
    )}
    {...props}
  />
))
TooltipContent.displayName = TooltipPrimitive.Content.displayName

export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }
[V0_FILE]typescriptreact:file="components/ui/use-mobile.tsx"
import * as React from "react"

const MOBILE_BREAKPOINT = 768

export function useIsMobile() {
  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)

React.useEffect(() => {
    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
    const onChange = () => {
      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
    }
    mql.addEventListener("change", onChange)
    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
    return () => mql.removeEventListener("change", onChange)
  }, [])

return !!isMobile
}
[V0_FILE]typescript:file="components/ui/use-toast.ts"
"use client"

// Inspired by react-hot-toast library
import * as React from "react"

import type {
  ToastActionElement,
  ToastProps,
} from "@/components/ui/toast"

const TOAST_LIMIT = 1
const TOAST_REMOVE_DELAY = 1000000

type ToasterToast = ToastProps & {
  id: string
  title?: React.ReactNode
  description?: React.ReactNode
  action?: ToastActionElement
}

const actionTypes = {
  ADD_TOAST: "ADD_TOAST",
  UPDATE_TOAST: "UPDATE_TOAST",
  DISMISS_TOAST: "DISMISS_TOAST",
  REMOVE_TOAST: "REMOVE_TOAST",
} as const

let count = 0

function genId() {
  count = (count + 1) % Number.MAX_SAFE_INTEGER
  return count.toString()
}

type ActionType = typeof actionTypes

type Action =
  | {
      type: ActionType["ADD_TOAST"]
      toast: ToasterToast
    }
  | {
      type: ActionType["UPDATE_TOAST"]
      toast: Partial<ToasterToast>
    }
  | {
      type: ActionType["DISMISS_TOAST"]
      toastId?: ToasterToast["id"]
    }
  | {
      type: ActionType["REMOVE_TOAST"]
      toastId?: ToasterToast["id"]
    }

interface State {
  toasts: ToasterToast[]
}

const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()

const addToRemoveQueue = (toastId: string) => {
  if (toastTimeouts.has(toastId)) {
    return
  }

const timeout = setTimeout(() => {
    toastTimeouts.delete(toastId)
    dispatch({
      type: "REMOVE_TOAST",
      toastId: toastId,
    })
  }, TOAST_REMOVE_DELAY)

toastTimeouts.set(toastId, timeout)
}

export const reducer = (state: State, action: Action): State => {
  switch (action.type) {
    case "ADD_TOAST":
      return {
        ...state,
        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
      }

case "UPDATE_TOAST":
      return {
        ...state,
        toasts: state.toasts.map((t) =>
          t.id === action.toast.id ? { ...t, ...action.toast } : t
        ),
      }

case "DISMISS_TOAST": {
      const { toastId } = action

// ! Side effects ! - This could be extracted into a dismissToast() action,
      // but I'll keep it here for simplicity
      if (toastId) {
        addToRemoveQueue(toastId)
      } else {
        state.toasts.forEach((toast) => {
          addToRemoveQueue(toast.id)
        })
      }

return {
        ...state,
        toasts: state.toasts.map((t) =>
          t.id === toastId || toastId === undefined
            ? {
                ...t,
                open: false,
              }
            : t
        ),
      }
    }
    case "REMOVE_TOAST":
      if (action.toastId === undefined) {
        return {
          ...state,
          toasts: [],
        }
      }
      return {
        ...state,
        toasts: state.toasts.filter((t) => t.id !== action.toastId),
      }
  }
}

const listeners: Array<(state: State) => void> = []

let memoryState: State = { toasts: [] }

function dispatch(action: Action) {
  memoryState = reducer(memoryState, action)
  listeners.forEach((listener) => {
    listener(memoryState)
  })
}

type Toast = Omit<ToasterToast, "id">

function toast({ ...props }: Toast) {
  const id = genId()

const update = (props: ToasterToast) =>
    dispatch({
      type: "UPDATE_TOAST",
      toast: { ...props, id },
    })
  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })

dispatch({
    type: "ADD_TOAST",
    toast: {
      ...props,
      id,
      open: true,
      onOpenChange: (open) => {
        if (!open) dismiss()
      },
    },
  })

return {
    id: id,
    dismiss,
    update,
  }
}

function useToast() {
  const [state, setState] = React.useState<State>(memoryState)

React.useEffect(() => {
    listeners.push(setState)
    return () => {
      const index = listeners.indexOf(setState)
      if (index > -1) {
        listeners.splice(index, 1)
      }
    }
  }, [state])

return {
    ...state,
    toast,
    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
  }
}

export { useToast, toast }
[V0_FILE]typescriptreact:file="hooks/use-mobile.tsx"
import * as React from "react"

const MOBILE_BREAKPOINT = 768

export function useIsMobile() {
  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)

return !!isMobile
}
[V0_FILE]typescript:file="hooks/use-toast.ts"
"use client"

// Inspired by react-hot-toast library
import * as React from "react"

import type {
  ToastActionElement,
  ToastProps,
} from "@/components/ui/toast"

const TOAST_LIMIT = 1
const TOAST_REMOVE_DELAY = 1000000

type ToasterToast = ToastProps & {
  id: string
  title?: React.ReactNode
  description?: React.ReactNode
  action?: ToastActionElement
}

const actionTypes = {
  ADD_TOAST: "ADD_TOAST",
  UPDATE_TOAST: "UPDATE_TOAST",
  DISMISS_TOAST: "DISMISS_TOAST",
  REMOVE_TOAST: "REMOVE_TOAST",
} as const

let count = 0

function genId() {
  count = (count + 1) % Number.MAX_SAFE_INTEGER
  return count.toString()
}

type ActionType = typeof actionTypes

interface State {
  toasts: ToasterToast[]
}

const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()

const addToRemoveQueue = (toastId: string) => {
  if (toastTimeouts.has(toastId)) {
    return
  }

const timeout = setTimeout(() => {
    toastTimeouts.delete(toastId)
    dispatch({
      type: "REMOVE_TOAST",
      toastId: toastId,
    })
  }, TOAST_REMOVE_DELAY)

toastTimeouts.set(toastId, timeout)
}

case "UPDATE_TOAST":
      return {
        ...state,
        toasts: state.toasts.map((t) =>
          t.id === action.toast.id ? { ...t, ...action.toast } : t
        ),
      }

case "DISMISS_TOAST": {
      const { toastId } = action

const listeners: Array<(state: State) => void> = []

let memoryState: State = { toasts: [] }

function dispatch(action: Action) {
  memoryState = reducer(memoryState, action)
  listeners.forEach((listener) => {
    listener(memoryState)
  })
}

type Toast = Omit<ToasterToast, "id">

function toast({ ...props }: Toast) {
  const id = genId()

const update = (props: ToasterToast) =>
    dispatch({
      type: "UPDATE_TOAST",
      toast: { ...props, id },
    })
  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })

dispatch({
    type: "ADD_TOAST",
    toast: {
      ...props,
      id,
      open: true,
      onOpenChange: (open) => {
        if (!open) dismiss()
      },
    },
  })

return {
    id: id,
    dismiss,
    update,
  }
}

function useToast() {
  const [state, setState] = React.useState<State>(memoryState)

return {
    ...state,
    toast,
    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
  }
}

export { useToast, toast }
[V0_FILE]typescript:file="lib/utils.ts"
import { type ClassValue, clsx } from "clsx"
import { twMerge } from "tailwind-merge"

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}
[V0_FILE]javascript:file="next.config.mjs"
/** @type {import('next').NextConfig} */
const nextConfig = {
  eslint: {
    ignoreDuringBuilds: true,
  },
  typescript: {
    ignoreBuildErrors: true,
  },
  images: {
    unoptimized: true,
  },
}

export default nextConfig
[V0_FILE]json:file="package.json"
{
  "name": "my-v0-project",
  "version": "0.1.0",
  "private": true,
  "scripts": {
    "build": "next build",
    "dev": "next dev",
    "lint": "next lint",
    "start": "next start"
  },
  "dependencies": {
    "@hookform/resolvers": "^3.9.1",
    "@radix-ui/react-accordion": "1.2.2",
    "@radix-ui/react-alert-dialog": "1.1.4",
    "@radix-ui/react-aspect-ratio": "1.1.1",
    "@radix-ui/react-avatar": "1.1.2",
    "@radix-ui/react-checkbox": "1.1.3",
    "@radix-ui/react-collapsible": "1.1.2",
    "@radix-ui/react-context-menu": "2.2.4",
    "@radix-ui/react-dialog": "latest",
    "@radix-ui/react-dropdown-menu": "2.1.4",
    "@radix-ui/react-hover-card": "1.1.4",
    "@radix-ui/react-label": "2.1.1",
    "@radix-ui/react-menubar": "1.1.4",
    "@radix-ui/react-navigation-menu": "1.2.3",
    "@radix-ui/react-popover": "1.1.4",
    "@radix-ui/react-progress": "1.1.1",
    "@radix-ui/react-radio-group": "1.2.2",
    "@radix-ui/react-scroll-area": "1.2.2",
    "@radix-ui/react-select": "2.1.4",
    "@radix-ui/react-separator": "1.1.1",
    "@radix-ui/react-slider": "1.2.2",
    "@radix-ui/react-slot": "1.1.1",
    "@radix-ui/react-switch": "1.1.2",
    "@radix-ui/react-tabs": "latest",
    "@radix-ui/react-toast": "1.2.4",
    "@radix-ui/react-toggle": "1.1.1",
    "@radix-ui/react-toggle-group": "1.1.1",
    "@radix-ui/react-tooltip": "1.1.6",
    "autoprefixer": "^10.4.20",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
    "cmdk": "1.0.4",
    "date-fns": "4.1.0",
    "embla-carousel-react": "8.5.1",
    "input-otp": "1.4.1",
    "lucide-react": "^0.454.0",
    "next": "15.2.4",
    "next-themes": "^0.4.4",
    "qrcode.react": "latest",
    "react": "^19",
    "react-day-picker": "8.10.1",
    "react-dom": "^19",
    "react-hook-form": "^7.54.1",
    "react-resizable-panels": "^2.1.7",
    "recharts": "latest",
    "sonner": "^1.7.1",
    "tailwind-merge": "^2.5.5",
    "tailwindcss-animate": "^1.0.7",
    "vaul": "^0.9.6",
    "zod": "^3.24.1"
  },
  "devDependencies": {
    "@types/node": "^22",
    "@types/react": "^19",
    "@types/react-dom": "^19",
    "postcss": "^8.5",
    "tailwindcss": "^3.4.17",
    "typescript": "^5"
  }
}
[V0_FILE]javascript:file="postcss.config.mjs"
/** @type {import('postcss-load-config').Config} */
const config = {
  plugins: {
    tailwindcss: {},
  },
};

export default config;
[V0_FILE]css:file="styles/globals.css"
@tailwind base;
@tailwind components;
@tailwind utilities;

body {
  font-family: Arial, Helvetica, sans-serif;
}

@layer utilities {
  .text-balance {
    text-wrap: balance;
  }
}

@layer base {
  :root {
    --background: 0 0% 100%;
    --foreground: 0 0% 3.9%;
    --card: 0 0% 100%;
    --card-foreground: 0 0% 3.9%;
    --popover: 0 0% 100%;
    --popover-foreground: 0 0% 3.9%;
    --primary: 0 0% 9%;
    --primary-foreground: 0 0% 98%;
    --secondary: 0 0% 96.1%;
    --secondary-foreground: 0 0% 9%;
    --muted: 0 0% 96.1%;
    --muted-foreground: 0 0% 45.1%;
    --accent: 0 0% 96.1%;
    --accent-foreground: 0 0% 9%;
    --destructive: 0 84.2% 60.2%;
    --destructive-foreground: 0 0% 98%;
    --border: 0 0% 89.8%;
    --input: 0 0% 89.8%;
    --ring: 0 0% 3.9%;
    --chart-1: 12 76% 61%;
    --chart-2: 173 58% 39%;
    --chart-3: 197 37% 24%;
    --chart-4: 43 74% 66%;
    --chart-5: 27 87% 67%;
    --radius: 0.5rem;
    --sidebar-background: 0 0% 98%;
    --sidebar-foreground: 240 5.3% 26.1%;
    --sidebar-primary: 240 5.9% 10%;
    --sidebar-primary-foreground: 0 0% 98%;
    --sidebar-accent: 240 4.8% 95.9%;
    --sidebar-accent-foreground: 240 5.9% 10%;
    --sidebar-border: 220 13% 91%;
    --sidebar-ring: 217.2 91.2% 59.8%;
  }
  .dark {
    --background: 0 0% 3.9%;
    --foreground: 0 0% 98%;
    --card: 0 0% 3.9%;
    --card-foreground: 0 0% 98%;
    --popover: 0 0% 3.9%;
    --popover-foreground: 0 0% 98%;
    --primary: 0 0% 98%;
    --primary-foreground: 0 0% 9%;
    --secondary: 0 0% 14.9%;
    --secondary-foreground: 0 0% 98%;
    --muted: 0 0% 14.9%;
    --muted-foreground: 0 0% 63.9%;
    --accent: 0 0% 14.9%;
    --accent-foreground: 0 0% 98%;
    --destructive: 0 62.8% 30.6%;
    --destructive-foreground: 0 0% 98%;
    --border: 0 0% 14.9%;
    --input: 0 0% 14.9%;
    --ring: 0 0% 83.1%;
    --chart-1: 220 70% 50%;
    --chart-2: 160 60% 45%;
    --chart-3: 30 80% 55%;
    --chart-4: 280 65% 60%;
    --chart-5: 340 75% 55%;
    --sidebar-background: 240 5.9% 10%;
    --sidebar-foreground: 240 4.8% 95.9%;
    --sidebar-primary: 224.3 76.3% 48%;
    --sidebar-primary-foreground: 0 0% 100%;
    --sidebar-accent: 240 3.7% 15.9%;
    --sidebar-accent-foreground: 240 4.8% 95.9%;
    --sidebar-border: 240 3.7% 15.9%;
    --sidebar-ring: 217.2 91.2% 59.8%;
  }
}

@layer base {
  * {
    @apply border-border;
  }
  body {
    @apply bg-background text-foreground;
  }
}
[V0_FILE]typescript:file="tailwind.config.ts"
import type { Config } from "tailwindcss";

# dependencies
/node_modules

# next.js
/.next/
/out/

# production
/build

# debug
npm-debug.log*
yarn-debug.log*
yarn-error.log*
.pnpm-debug.log*

# env files
.env*

# vercel
.vercel

# typescript
*.tsbuildinfo
next-env.d.ts
[V0_FILE]markdown:file="README.md"
# OMR sheet generator

*Automatically synced with your [v0.dev](https://v0.dev) deployments*

[![Deployed on Vercel](https://img.shields.io/badge/Deployed%20on-Vercel-black?style=for-the-badge&logo=vercel)](https://vercel.com/khulnasoft-projects/bossomr)
[![Built with v0](https://img.shields.io/badge/Built%20with-v0.dev-black?style=for-the-badge)](https://v0.dev/chat/projects/O3Rm6sdsWbF)

## Overview

This repository will stay in sync with your deployed chats on [v0.dev](https://v0.dev).
Any changes you make to your deployed app will be automatically pushed to this repository from [v0.dev](https://v0.dev).

## Deployment

Your project is live at:

**[https://vercel.com/khulnasoft-projects/bossomr](https://vercel.com/khulnasoft-projects/bossomr)**

## Build your app

Continue building your app on:

**[https://v0.dev/chat/projects/O3Rm6sdsWbF](https://v0.dev/chat/projects/O3Rm6sdsWbF)**

## How It Works

1. Create and modify your project using [v0.dev](https://v0.dev)
2. Deploy your chats from the v0 interface
3. Changes are automatically pushed to this repository
4. Vercel deploys the latest version from this repository
[V0_FILE]css:file="app/globals.css"
@tailwind base;
@tailwind components;
@tailwind utilities;

@layer base {
  :root {
    --background: 0 0% 100%;
    --foreground: 222.2 84% 4.9%;
    --card: 0 0% 100%;
    --card-foreground: 222.2 84% 4.9%;
    --popover: 0 0% 100%;
    --popover-foreground: 222.2 84% 4.9%;
    --primary: 214 100% 48%;
    --primary-foreground: 210 40% 98%;
    --secondary: 210 40% 96.1%;
    --secondary-foreground: 222.2 47.4% 11.2%;
    --muted: 210 40% 96.1%;
    --muted-foreground: 215.4 16.3% 46.9%;
    --accent: 210 40% 96.1%;
    --accent-foreground: 222.2 47.4% 11.2%;
    --destructive: 0 84.2% 60.2%;
    --destructive-foreground: 210 40% 98%;
    --border: 214.3 31.8% 91.4%;
    --input: 214.3 31.8% 91.4%;
    --ring: 214 100% 48%;
    --radius: 0.5rem;
  }

.dark {
    --background: 222.2 84% 4.9%;
    --foreground: 210 40% 98%;
    --card: 222.2 84% 4.9%;
    --card-foreground: 210 40% 98%;
    --popover: 222.2 84% 4.9%;
    --popover-foreground: 210 40% 98%;
    --primary: 214 100% 48%;
    --primary-foreground: 210 40% 98%;
    --secondary: 217.2 32.6% 17.5%;
    --secondary-foreground: 210 40% 98%;
    --muted: 217.2 32.6% 17.5%;
    --muted-foreground: 215 20.2% 65.1%;
    --accent: 217.2 32.6% 17.5%;
    --accent-foreground: 210 40% 98%;
    --destructive: 0 62.8% 30.6%;
    --destructive-foreground: 210 40% 98%;
    --border: 217.2 32.6% 17.5%;
    --input: 217.2 32.6% 17.5%;
    --ring: 214 100% 48%;
  }
}

@layer base {
  * {
    @apply border-border;
  }
  body {
    @apply bg-background text-foreground;
    font-feature-settings: "rlig" 1, "calt" 1;
  }
}

.glass-card {
  background: rgba(18, 18, 18, 0.7);
  backdrop-filter: blur(10px);
  border: 1px solid rgba(255, 255, 255, 0.1);
  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
}

.glass-panel {
  background: rgba(30, 30, 30, 0.6);
  backdrop-filter: blur(8px);
  border: 1px solid rgba(255, 255, 255, 0.08);
}

.blue-glow {
  box-shadow: 0 0 15px rgba(0, 112, 243, 0.5);
}

.grid-pattern {
  background-image: linear-gradient(rgba(255, 255, 255, 0.05) 1px, transparent 1px),
    linear-gradient(90deg, rgba(255, 255, 255, 0.05) 1px, transparent 1px);
  background-size: 20px 20px;
}
[V0_FILE]typescriptreact:file="app/layout.tsx"
import type React from "react"
import "@/app/globals.css"
import { Inter } from "next/font/google"
import { ThemeProvider } from "@/components/theme-provider"

const inter = Inter({ subsets: ["latin"] })

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en" suppressHydrationWarning>
      <head>
        <title>OMR Sheet Generator</title>
        <meta name="description" content="Generate customizable OMR sheets for exams and surveys" />
      </head>
      <body className={`${inter.className} dark`}>
        <ThemeProvider attribute="class" defaultTheme="dark" enableSystem={false} disableTransitionOnChange>
          {children}
        </ThemeProvider>
      </body>
    </html>
  )
}

export const metadata = {
      generator: 'v0.dev'
    };
[V0_FILE]typescriptreact:file="app/page.tsx"
import { OMRSheetGenerator } from "@/components/omr-sheet-generator"

export default function Home() {
  return (
    <main className="min-h-screen grid-pattern py-8 px-4">
      <div className="container mx-auto">
        <div className="flex flex-col items-center mb-8">
          <h1 className="text-4xl font-bold text-white mb-2 tracking-tight">OMR Sheet Generator</h1>
          <p className="text-gray-400 text-center max-w-2xl">
            Create customizable optical mark recognition sheets for exams, surveys, and assessments
          </p>
        </div>
        <OMRSheetGenerator />
      </div>
    </main>
  )
}
[V0_FILE]json:file="components.json"
{
  "$schema": "https://ui.shadcn.com/schema.json",
  "style": "default",
  "rsc": true,
  "tsx": true,
  "tailwind": {
    "config": "tailwind.config.ts",
    "css": "app/globals.css",
    "baseColor": "neutral",
    "cssVariables": true,
    "prefix": ""
  },
  "aliases": {
    "components": "@/components",
    "utils": "@/lib/utils",
    "ui": "@/components/ui",
    "lib": "@/lib",
    "hooks": "@/hooks"
  },
  "iconLibrary": "lucide"
}
[V0_FILE]typescriptreact:file="components/analytics-dashboard.tsx"
"use client"

import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
import { Badge } from "@/components/ui/badge"
import {
  BarChart,
  Bar,
  XAxis,
  YAxis,
  CartesianGrid,
  Tooltip,
  ResponsiveContainer,
  PieChart,
  Pie,
  Cell,
  LineChart,
  Line,
} from "recharts"
import { TrendingUp, Users, Target, Award, AlertTriangle, CheckCircle } from "lucide-react"

interface StudentResponse {
  id: string
  name: string
  rollNumber: string
  responses: Record<number, string>
  score: number
  percentage: number
  timestamp: Date
}

interface AnalyticsDashboardProps {
  config: {
    title: string
    numQuestions: number
    optionsPerQuestion: number
    uniqueId: string
  }
  answerKey: Record<number, string>
  studentResponses: StudentResponse[]
}

export function AnalyticsDashboard({ config, answerKey, studentResponses }: AnalyticsDashboardProps) {
  const optionLetters = ["A", "B", "C", "D", "E"]

const getScoreDistribution = () => {
    const ranges = [
      { range: "0-20%", min: 0, max: 20, count: 0 },
      { range: "21-40%", min: 21, max: 40, count: 0 },
      { range: "41-60%", min: 41, max: 60, count: 0 },
      { range: "61-80%", min: 61, max: 80, count: 0 },
      { range: "81-100%", min: 81, max: 100, count: 0 },
    ]

studentResponses.forEach((response) => {
      const range = ranges.find((r) => response.percentage >= r.min && response.percentage <= r.max)
      if (range) range.count++
    })

return ranges
  }

const getQuestionAnalysis = () => {
    const analysis: Array<{
      question: number
      correctAnswers: number
      incorrectAnswers: number
      difficulty: string
      optionDistribution: Record<string, number>
    }> = []

for (let i = 1; i <= config.numQuestions; i++) {
      const correctAnswer = answerKey[i]
      let correctCount = 0
      let incorrectCount = 0
      const optionDistribution: Record<string, number> = {}

// Initialize option distribution
      optionLetters.slice(0, config.optionsPerQuestion).forEach((option) => {
        optionDistribution[option] = 0
      })

studentResponses.forEach((response) => {
        const studentAnswer = response.responses[i]
        if (studentAnswer) {
          optionDistribution[studentAnswer] = (optionDistribution[studentAnswer] || 0) + 1

if (correctAnswer && studentAnswer === correctAnswer) {
            correctCount++
          } else {
            incorrectCount++
          }
        }
      })

const totalResponses = correctCount + incorrectCount
      const difficultyPercentage = totalResponses > 0 ? (correctCount / totalResponses) * 100 : 0

let difficulty = "Easy"
      if (difficultyPercentage < 30) difficulty = "Hard"
      else if (difficultyPercentage < 70) difficulty = "Medium"

analysis.push({
        question: i,
        correctAnswers: correctCount,
        incorrectAnswers: incorrectCount,
        difficulty,
        optionDistribution,
      })
    }

return analysis
  }

const getAnswerKeyDistribution = () => {
    const distribution: Record<string, number> = {}

optionLetters.slice(0, config.optionsPerQuestion).forEach((option) => {
      distribution[option] = 0
    })

Object.values(answerKey).forEach((answer) => {
      distribution[answer] = (distribution[answer] || 0) + 1
    })

return Object.entries(distribution).map(([option, count]) => ({
      option,
      count,
    }))
  }

const getPerformanceTrend = () => {
    return studentResponses
      .slice()
      .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())
      .map((response, index) => ({
        submission: index + 1,
        percentage: response.percentage,
        name: response.name,
      }))
  }

const getTopPerformers = () => {
    return studentResponses
      .slice()
      .sort((a, b) => b.percentage - a.percentage)
      .slice(0, 5)
  }

const getStatistics = () => {
    if (studentResponses.length === 0) {
      return {
        averageScore: 0,
        highestScore: 0,
        lowestScore: 0,
        passRate: 0,
        totalStudents: 0,
      }
    }

const scores = studentResponses.map((r) => r.percentage)
    const averageScore = Math.round(scores.reduce((sum, score) => sum + score, 0) / scores.length)
    const highestScore = Math.max(...scores)
    const lowestScore = Math.min(...scores)
    const passRate = Math.round((scores.filter((score) => score >= 60).length / scores.length) * 100)

return {
      averageScore,
      highestScore,
      lowestScore,
      passRate,
      totalStudents: studentResponses.length,
    }
  }

const scoreDistribution = getScoreDistribution()
  const questionAnalysis = getQuestionAnalysis()
  const answerKeyDistribution = getAnswerKeyDistribution()
  const performanceTrend = getPerformanceTrend()
  const topPerformers = getTopPerformers()
  const statistics = getStatistics()

const COLORS = ["#0070f3", "#00d4aa", "#ff6b6b", "#ffd93d", "#6c5ce7"]

const hardQuestions = questionAnalysis.filter((q) => q.difficulty === "Hard").slice(0, 5)
  const easyQuestions = questionAnalysis.filter((q) => q.difficulty === "Easy").slice(0, 5)

return (
    <div className="space-y-6">
      {/* Key Statistics */}
      <div className="grid grid-cols-2 md:grid-cols-5 gap-4">
        <Card className="glass-card border-0">
          <CardContent className="p-4">
            <div className="flex items-center space-x-2">
              <Users className="h-5 w-5 text-[#0070f3]" />
              <div>
                <div className="text-2xl font-bold text-white">{statistics.totalStudents}</div>
                <div className="text-xs text-gray-400">Total Students</div>
              </div>
            </div>
          </CardContent>
        </Card>

<Card className="glass-card border-0">
          <CardContent className="p-4">
            <div className="flex items-center space-x-2">
              <Target className="h-5 w-5 text-green-400" />
              <div>
                <div className="text-2xl font-bold text-white">{statistics.averageScore}%</div>
                <div className="text-xs text-gray-400">Average Score</div>
              </div>
            </div>
          </CardContent>
        </Card>

<Card className="glass-card border-0">
          <CardContent className="p-4">
            <div className="flex items-center space-x-2">
              <Award className="h-5 w-5 text-yellow-400" />
              <div>
                <div className="text-2xl font-bold text-white">{statistics.highestScore}%</div>
                <div className="text-xs text-gray-400">Highest Score</div>
              </div>
            </div>
          </CardContent>
        </Card>

<Card className="glass-card border-0">
          <CardContent className="p-4">
            <div className="flex items-center space-x-2">
              <AlertTriangle className="h-5 w-5 text-red-400" />
              <div>
                <div className="text-2xl font-bold text-white">{statistics.lowestScore}%</div>
                <div className="text-xs text-gray-400">Lowest Score</div>
              </div>
            </div>
          </CardContent>
        </Card>

<Card className="glass-card border-0">
          <CardContent className="p-4">
            <div className="flex items-center space-x-2">
              <CheckCircle className="h-5 w-5 text-[#0070f3]" />
              <div>
                <div className="text-2xl font-bold text-white">{statistics.passRate}%</div>
                <div className="text-xs text-gray-400">Pass Rate</div>
              </div>
            </div>
          </CardContent>
        </Card>
      </div>

<div className="grid md:grid-cols-2 gap-6">
        {/* Score Distribution */}
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Score Distribution</CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <ResponsiveContainer width="100%" height={300}>
              <BarChart data={scoreDistribution}>
                <CartesianGrid strokeDasharray="3 3" stroke="#374151" />
                <XAxis dataKey="range" stroke="#9CA3AF" />
                <YAxis stroke="#9CA3AF" />
                <Tooltip
                  contentStyle={{
                    backgroundColor: "#1F2937",
                    border: "1px solid #374151",
                    borderRadius: "8px",
                    color: "#F9FAFB",
                  }}
                />
                <Bar dataKey="count" fill="#0070f3" />
              </BarChart>
            </ResponsiveContainer>
          </CardContent>
        </Card>

{/* Answer Key Distribution */}
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Answer Key Distribution</CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <ResponsiveContainer width="100%" height={300}>
              <PieChart>
                <Pie
                  data={answerKeyDistribution}
                  cx="50%"
                  cy="50%"
                  labelLine={false}
                  label={({ option, count }) => `${option}: ${count}`}
                  outerRadius={80}
                  fill="#8884d8"
                  dataKey="count"
                >
                  {answerKeyDistribution.map((entry, index) => (
                    <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
                  ))}
                </Pie>
                <Tooltip
                  contentStyle={{
                    backgroundColor: "#1F2937",
                    border: "1px solid #374151",
                    borderRadius: "8px",
                    color: "#F9FAFB",
                  }}
                />
              </PieChart>
            </ResponsiveContainer>
          </CardContent>
        </Card>
      </div>

{/* Performance Trend */}
      {performanceTrend.length > 0 && (
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white flex items-center gap-2">
              <TrendingUp size={20} />
              Performance Trend
            </CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <ResponsiveContainer width="100%" height={300}>
              <LineChart data={performanceTrend}>
                <CartesianGrid strokeDasharray="3 3" stroke="#374151" />
                <XAxis dataKey="submission" stroke="#9CA3AF" />
                <YAxis stroke="#9CA3AF" />
                <Tooltip
                  contentStyle={{
                    backgroundColor: "#1F2937",
                    border: "1px solid #374151",
                    borderRadius: "8px",
                    color: "#F9FAFB",
                  }}
                />
                <Line type="monotone" dataKey="percentage" stroke="#0070f3" strokeWidth={2} />
              </LineChart>
            </ResponsiveContainer>
          </CardContent>
        </Card>
      )}

<div className="grid md:grid-cols-3 gap-6">
        {/* Top Performers */}
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Top Performers</CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <div className="space-y-3">
              {topPerformers.length === 0 ? (
                <p className="text-gray-400 text-center py-4">No data available</p>
              ) : (
                topPerformers.map((student, index) => (
                  <div key={student.id} className="flex items-center justify-between bg-black/20 p-3 rounded-lg">
                    <div className="flex items-center space-x-3">
                      <Badge className="bg-[#0070f3]/20 text-[#0070f3] border-[#0070f3]/30">#{index + 1}</Badge>
                      <div>
                        <div className="font-medium text-white">{student.name}</div>
                        <div className="text-xs text-gray-400">Roll: {student.rollNumber}</div>
                      </div>
                    </div>
                    <Badge className="bg-green-900/30 text-green-400 border-green-900/50">{student.percentage}%</Badge>
                  </div>
                ))
              )}
            </div>
          </CardContent>
        </Card>

{/* Difficult Questions */}
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Most Difficult Questions</CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <div className="space-y-3">
              {hardQuestions.length === 0 ? (
                <p className="text-gray-400 text-center py-4">No difficult questions identified</p>
              ) : (
                hardQuestions.map((question) => (
                  <div key={question.question} className="bg-black/20 p-3 rounded-lg">
                    <div className="flex justify-between items-center mb-2">
                      <span className="font-medium text-white">Question {question.question}</span>
                      <Badge className="bg-red-900/30 text-red-400 border-red-900/50">{question.difficulty}</Badge>
                    </div>
                    <div className="text-xs text-gray-400">
                      Correct: {question.correctAnswers} | Incorrect: {question.incorrectAnswers}
                    </div>
                    <div className="text-xs text-gray-400">
                      Success Rate:{" "}
                      {question.correctAnswers + question.incorrectAnswers > 0
                        ? Math.round(
                            (question.correctAnswers / (question.correctAnswers + question.incorrectAnswers)) * 100,
                          )
                        : 0}
                      %
                    </div>
                  </div>
                ))
              )}
            </div>
          </CardContent>
        </Card>

{/* Easy Questions */}
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Easiest Questions</CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <div className="space-y-3">
              {easyQuestions.length === 0 ? (
                <p className="text-gray-400 text-center py-4">No easy questions identified</p>
              ) : (
                easyQuestions.map((question) => (
                  <div key={question.question} className="bg-black/20 p-3 rounded-lg">
                    <div className="flex justify-between items-center mb-2">
                      <span className="font-medium text-white">Question {question.question}</span>
                      <Badge className="bg-green-900/30 text-green-400 border-green-900/50">
                        {question.difficulty}
                      </Badge>
                    </div>
                    <div className="text-xs text-gray-400">
                      Correct: {question.correctAnswers} | Incorrect: {question.incorrectAnswers}
                    </div>
                    <div className="text-xs text-gray-400">
                      Success Rate:{" "}
                      {question.correctAnswers + question.incorrectAnswers > 0
                        ? Math.round(
                            (question.correctAnswers / (question.correctAnswers + question.incorrectAnswers)) * 100,
                          )
                        : 0}
                      %
                    </div>
                  </div>
                ))
              )}
            </div>
          </CardContent>
        </Card>
      </div>

{/* Question-wise Analysis */}
      {questionAnalysis.length > 0 && (
        <Card className="glass-card border-0">
          <CardHeader className="border-b border-gray-800">
            <CardTitle className="text-white">Question-wise Performance Analysis</CardTitle>
          </CardHeader>
          <CardContent className="pt-6">
            <div className="max-h-96 overflow-y-auto">
              <div className="grid grid-cols-6 gap-2 text-xs font-bold mb-2 sticky top-0 bg-black/80 p-2 rounded">
                <div className="text-gray-300">Question</div>
                <div className="text-green-400">Correct</div>
                <div className="text-red-400">Incorrect</div>
                <div className="text-yellow-400">Success Rate</div>
                <div className="text-purple-400">Difficulty</div>
                <div className="text-blue-400">Answer Key</div>
              </div>

<div className="space-y-1">
                {questionAnalysis.map((question) => {
                  const totalResponses = question.correctAnswers + question.incorrectAnswers
                  const successRate =
                    totalResponses > 0 ? Math.round((question.correctAnswers / totalResponses) * 100) : 0

return (
                    <div key={question.question} className="grid grid-cols-6 gap-2 text-sm p-2 rounded bg-black/20">
                      <div className="text-gray-300 font-medium">{question.question}</div>
                      <div className="text-green-400">{question.correctAnswers}</div>
                      <div className="text-red-400">{question.incorrectAnswers}</div>
                      <div className="text-yellow-400">{successRate}%</div>
                      <div>
                        <Badge
                          className={
                            question.difficulty === "Easy"
                              ? "bg-green-900/30 text-green-400 border-green-900/50"
                              : question.difficulty === "Medium"
                                ? "bg-yellow-900/30 text-yellow-400 border-yellow-900/50"
                                : "bg-red-900/30 text-red-400 border-red-900/50"
                          }
                        >
                          {question.difficulty}
                        </Badge>
                      </div>
                      <div className="text-blue-400 font-medium">{answerKey[question.question] || "-"}</div>
                    </div>
                  )
                })}
              </div>
            </div>
          </CardContent>
        </Card>
      )}
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/answer-key-comparison.tsx"
"use client"

import { useState } from "react"
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Badge } from "@/components/ui/badge"
import { Textarea } from "@/components/ui/textarea"
import { Alert, AlertDescription } from "@/components/ui/alert"
import { GitCompare, Download, AlertTriangle } from "lucide-react"

interface AnswerKeyComparisonProps {
  config: {
    title: string
    numQuestions: number
    optionsPerQuestion: number
    uniqueId: string
  }
  primaryAnswers: Record<number, string>
  onAnswerChange: (questionNum: number, answer: string) => void
}

export function AnswerKeyComparison({ config, primaryAnswers, onAnswerChange }: AnswerKeyComparisonProps) {
  const [secondaryAnswers, setSecondaryAnswers] = useState<Record<number, string>>({})
  const [comparisonName, setComparisonName] = useState("Comparison Answer Key")
  const [importText, setImportText] = useState("")

const optionLetters = ["A", "B", "C", "D", "E"]

const parseImportText = (text: string) => {
    if (!text.trim()) return

try {
      const lines = text.trim().split("\n")
      const parsed: Record<number, string> = {}
      const validOptions = optionLetters.slice(0, config.optionsPerQuestion)

const firstLine = lines[0].trim()

if (firstLine.includes(",") || firstLine.includes("\t")) {
        lines.forEach((line, index) => {
          const parts = line.split(/[,\t]/).map((p) => p.trim())

if (parts.length >= 2) {
            const questionNum = Number.parseInt(parts[0].replace(/\D/g, "")) || index + 1
            const answer = parts[1].toUpperCase()

setSecondaryAnswers(parsed)
    } catch (error) {
      console.error("Error parsing answers:", error)
    }
  }

const clearSecondary = () => {
    setSecondaryAnswers({})
    setImportText("")
  }

const copyFromPrimary = () => {
    setSecondaryAnswers({ ...primaryAnswers })
  }

const exportComparison = () => {
    const differences = getDifferences()
    let csvContent = "Question,Primary Answer,Secondary Answer,Match\n"

for (let i = 1; i <= config.numQuestions; i++) {
      const primary = primaryAnswers[i] || "-"
      const secondary = secondaryAnswers[i] || "-"
      const match = primary === secondary ? "Yes" : "No"
      csvContent += `${i},${primary},${secondary},${match}\n`
    }

const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" })
    const url = URL.createObjectURL(blob)
    const link = document.createElement("a")
    link.setAttribute("href", url)
    link.setAttribute("download", `answer_key_comparison_${config.uniqueId}.csv`)
    link.style.visibility = "hidden"
    document.body.appendChild(link)
    link.click()
    document.body.removeChild(link)
  }

const getDifferences = () => {
    const differences: Array<{
      question: number
      primary: string
      secondary: string
    }> = []

for (let i = 1; i <= config.numQuestions; i++) {
      const primary = primaryAnswers[i]
      const secondary = secondaryAnswers[i]

if (primary && secondary && primary !== secondary) {
        differences.push({
          question: i,
          primary,
          secondary,
        })
      }
    }

return differences
  }

const getStatistics = () => {
    const primaryCount = Object.keys(primaryAnswers).length
    const secondaryCount = Object.keys(secondaryAnswers).length
    const differences = getDifferences()
    const matches = Math.min(primaryCount, secondaryCount) - differences.length

return {
      primaryCount,
      secondaryCount,
      matches,
      differences: differences.length,
      accuracy: secondaryCount > 0 ? Math.round((matches / Math.min(primaryCount, secondaryCount)) * 100) : 0,
    }
  }

const statistics = getStatistics()
  const differences = getDifferences()

return (
    <div className="grid md:grid-cols-2 gap-8">
      <Card className="glass-card border-0">
        <CardHeader className="border-b border-gray-800">
          <CardTitle className="text-white flex items-center gap-2">
            <GitCompare size={20} />
            Answer Key Comparison
          </CardTitle>
        </CardHeader>
        <CardContent className="space-y-6 pt-6">
          <div className="space-y-2">
            <Label htmlFor="comparison-name" className="text-gray-300">
              Comparison Name
            </Label>
            <Input
              id="comparison-name"
              value={comparisonName}
              onChange={(e) => setComparisonName(e.target.value)}
              className="bg-black/40 border-gray-700"
            />
          </div>

<div className="space-y-2">
            <Label htmlFor="import-secondary" className="text-gray-300">
              Import Secondary Answer Key
            </Label>
            <Textarea
              id="import-secondary"
              value={importText}
              onChange={(e) => {
                setImportText(e.target.value)
                parseImportText(e.target.value)
              }}
              placeholder="Paste answers here (CSV, plain text, or space-separated)..."
              className="h-32 bg-black/40 border-gray-700 text-white"
            />
          </div>