Next.js Components
TailAdmin Next.js offers a curated set of customizable, accessible UI components designed to accelerate dashboard development. Built with Next.js 16 (App Router), React 19, Tailwind CSS v4, and Base UI , each component combines clean design with robust accessibility.
UI Primitives & Accessibility
TailAdmin Next.js uses Base UI as the headless foundation for its UI primitives located in src/components/ui/.
Using Base UI ensures comprehensive accessibility management across your application:
- WAI-ARIA Compliance: Built-in support for ARIA roles, attributes, and screen reader announcements.
- Keyboard Navigation & Focus Management: Native keyboard interactions (such as Escape to dismiss, Arrow keys for list traversal, and automatic focus trapping/restoration in modals).
- Headless Flexibility: Unstyled compound components that adapt to Tailwind CSS v4 classes without style conflicts or extra runtime bloat.
- State-driven Attributes: Primitives expose declarative data attributes (
data-open,data-closed,data-highlighted,data-disabled) for seamless animation and styling.
For the complete API reference, props specification, and component anatomy for any primitive, refer to the Base UI Documentation .
Usage Instructions
Primitives are stored in src/components/ui/ and are imported directly into your pages and layouts.
Static Component
For static elements without internal state (such as Buttons, Badges, or Avatars), import the primitive and pass your desired variant, size, or Tailwind classes:
import { Button } from "@/components/ui/button";
export default function ButtonExample() {
return (
<div className="flex flex-wrap items-center gap-3">
<Button variant="default" size="sm">
Primary Action
</Button>
<Button variant="outline" size="sm">
Secondary Outline
</Button>
<Button variant="ghost" size="sm">
Ghost
</Button>
<Button variant="destructive" size="sm">
Delete
</Button>
</div>
);
}Interactive Components
Interactive elements (such as Dropdowns, Dialogs, Popovers, Tabs, and Selects) use compound components that coordinate state and accessibility attributes automatically.
Dropdown Menu
The dropdown primitive uses Base UI Menu under the hood, managing trigger interactions, keyboard navigation, and popover positioning.
import { Button } from "@/components/ui/button";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown";
export default function DropdownExample() {
return (
<DropdownMenu>
<DropdownMenuTrigger render={<Button size="sm" variant="outline" />}>
Account Menu
</DropdownMenuTrigger>
<DropdownMenuContent align="start">
<DropdownMenuItem>Edit Profile</DropdownMenuItem>
<DropdownMenuItem>Account Settings</DropdownMenuItem>
<DropdownMenuItem>Support</DropdownMenuItem>
<DropdownMenuSeparator />
<DropdownMenuItem className="text-red-500 hover:text-red-600">
Sign Out
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
);
}Creating & Extending UI Primitives
When creating or extending a UI primitive in src/components/ui/:
- Import Base UI Primitive: Choose the appropriate headless primitive from
@base-ui/react. - Define Variants with CVA: Use
class-variance-authority(cva) to declare variant classes and size configurations using Tailwind CSS v4 tokens. - Attach
data-slot: Set a descriptivedata-slotattribute on each rendered element to support styling hooks and parent targeting. - Merge Classes: Wrap className with the
cn()utility (clsx+tailwind-merge) to allow consumer overrides. - Check Accessibility: Review the Base UI API Reference for required sub-components (such as
TitleandDescription) to ensure valid ARIA tree generation.
Forms & Validation
TailAdmin Next.js manages forms using React Hook Form paired with Zod schema validation via @hookform/resolvers/zod. Accessible form controls have been provided with compound Field primitives (Field, FieldLabel, FieldError, FieldDescription) from @/components/ui/field.
Schema Definition
Colocate a Zod validation schema alongside your form or feature module:
// schema.ts
import { z } from "zod";
export const loginSchema = z.object({
email: z
.string()
.trim()
.min(1, "Email address is required")
.email("Please enter a valid email address"),
password: z.string().min(6, "Password must be at least 6 characters"),
});
export type LoginFormData = z.infer<typeof loginSchema>;Form Component Implementation
Use useForm with zodResolver to connect validation to form state and render inputs wrapped in Field:
"use client";
import { Button } from "@/components/ui/button";
import {
Field,
FieldError,
FieldGroup,
FieldLabel,
} from "@/components/ui/field";
import { Input } from "@/components/ui/input";
import { zodResolver } from "@hookform/resolvers/zod";
import { useForm } from "react-hook-form";
import { loginSchema, type LoginFormData } from "./schema";
export default function LoginForm() {
const {
register,
handleSubmit,
formState: { errors, isSubmitting },
} = useForm<LoginFormData>({
resolver: zodResolver(loginSchema),
defaultValues: {
email: "",
password: "",
},
mode: "onTouched",
});
const onSubmit = (data: LoginFormData) => {
console.log("Form data:", data);
};
return (
<form onSubmit={handleSubmit(onSubmit)} noValidate>
<FieldGroup className="space-y-4">
<Field data-invalid={Boolean(errors.email)}>
<FieldLabel>Email</FieldLabel>
<Input
{...register("email")}
type="email"
placeholder="[email protected]"
aria-invalid={errors.email ? "true" : undefined}
/>
<FieldError errors={[errors.email]} />
</Field>
<Field data-invalid={Boolean(errors.password)}>
<FieldLabel>Password</FieldLabel>
<Input
{...register("password")}
type="password"
placeholder="Enter password"
aria-invalid={errors.password ? "true" : undefined}
/>
<FieldError errors={[errors.password]} />
</Field>
<Button type="submit" disabled={isSubmitting} className="w-full">
{isSubmitting ? "Signing in..." : "Sign In"}
</Button>
</FieldGroup>
</form>
);
}- Field Association:
Fielduses React Context to link theFieldLabelto its nestedInputvia generated IDs. - Validation State: Setting
data-invalid={Boolean(errors[field])}andaria-invalidtriggers Tailwind error styling and ensures accessible feedback. - Accessible Errors:
FieldErrorrenders error text withrole="alert"for screen reader announcements.
Tables
TailAdmin Next.js provides semantic table primitives under @/components/ui/table (Table, TableHeader, TableBody, TableRow, TableCell). TailAdmin Next.js also ships with Tanstack Table for building complex and interactive tables.
Basic Table
Create a basic table by using the Table primitives:
import {
Table,
TableBody,
TableCell,
TableHeader,
TableRow,
} from "@/components/ui/table";
interface User {
id: string;
name: string;
role: string;
status: string;
}
export default function BasicTableExample({ users }: { users: User[] }) {
return (
<Table>
<TableHeader className="border-b border-gray-100 dark:border-white/5">
<TableRow>
<TableCell
isHeader
className="px-5 py-3 text-start text-xs font-medium text-gray-500 dark:text-gray-400"
>
User
</TableCell>
<TableCell
isHeader
className="px-5 py-3 text-start text-xs font-medium text-gray-500 dark:text-gray-400"
>
Role
</TableCell>
<TableCell
isHeader
className="px-5 py-3 text-start text-xs font-medium text-gray-500 dark:text-gray-400"
>
Status
</TableCell>
</TableRow>
</TableHeader>
<TableBody className="divide-y divide-gray-100 dark:divide-white/5">
{users.map((user) => (
<TableRow key={user.id}>
<TableCell className="px-5 py-4 text-sm font-medium text-gray-800 dark:text-white/90">
{user.name}
</TableCell>
<TableCell className="px-5 py-4 text-sm text-gray-500 dark:text-gray-400">
{user.role}
</TableCell>
<TableCell className="px-5 py-4 text-sm text-gray-500 dark:text-gray-400">
{user.status}
</TableCell>
</TableRow>
))}
</TableBody>
</Table>
);
}Advance Data Table
For advanced features such as sorting, global search filtering, and pagination, combine the table primitives with @tanstack/react-table. Check Tanstack Table documentation here for more details.