@robomous/ui-core 0.1.0

package/src/primitives/primitives.test.tsx

@@ -0,0 +1,440 @@
+/**
+ * The component harness, proved on the primitives that carry a decision.
+ *
+ * Not a snapshot of every class string — that would pin the design system to
+ * whatever it happened to be on the day. What is asserted here is the handful of behaviours a screen
+ * would silently lose: the merge that makes `className` a real override — and the
+ * two geometry overrides that ride on it, `inlineLink` and `menuSurface`, whose
+ * whole job is to beat a canonical utility — the `asChild` that keeps a link a
+ * link, and the role an error is announced with.
+ *
+ * The button no longer defaults `type`, so nothing here stops a "Cancel"
+ * submitting a form; that is a call-site property now, and
+ * `tests/scripts/form_buttons.test.mjs` is what holds it.
+ *
+ * This file is also the reason the jsdom harness exists at all: standing the
+ * environment up once here is cheaper than the first screen that needs it doing so
+ * under deadline.
+ */
+
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import type { JSX } from "react";
+import { describe, expect, it } from "vitest";
+
+import { inlineLink } from "../lib/button";
+import { menuSurface } from "../lib/menu";
+import { progressAria } from "../lib/progress";
+import { twoLineTrigger } from "../lib/select";
+import { Alert, AlertDescription, AlertTitle } from "./alert";
+import { Badge } from "./badge";
+import { Button } from "./button";
+import { Card, CardTitle } from "./card";
+import { Dialog, DialogContent, DialogDescription, DialogTitle } from "./dialog";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "./dropdown-menu";
+import { Progress } from "./progress";
+import { FieldError } from "./field";
+import { Input } from "./input";
+import { Label } from "./label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "./select";
+import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from "./sheet";
+import { Table, TableBody, TableHead, TableHeader, TableRow } from "./table";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "./tabs";
+
+describe("Button", () => {
+  it("keeps an explicit type", () => {
+    render(<Button type="submit">Go</Button>);
+    expect(screen.getByRole("button").getAttribute("type")).toBe("submit");
+  });
+
+  it("lets a caller override a conflicting utility rather than emitting both", () => {
+    // Without `tailwind-merge` both `px-4` and `px-6` survive and which one wins is
+    // decided by the order Tailwind wrote them into the stylesheet — a rule nobody
+    // can see from the call site. This is what makes `className` an extension
+    // point rather than a suggestion.
+    render(<Button className="px-6">Wide</Button>);
+    const className = screen.getByRole("button", { name: "Wide" }).className;
+    expect(className).toContain("px-6");
+    expect(className).not.toContain("px-4");
+  });
+
+  it("renders the child element with asChild, so a link stays a link", () => {
+    render(
+      <Button asChild variant="default">
+        <a href="/projects">Projects</a>
+      </Button>,
+    );
+    // A `role="link"` on a `<button>` would read the same to a test and behave
+    // differently to a browser — no middle-click, no "open in new tab".
+    const link = screen.getByRole("link", { name: "Projects" });
+    expect(link.tagName).toBe("A");
+    expect(link.className).toContain("bg-primary");
+  });
+
+  it("styles a link button as an underline-on-hover text link", () => {
+    render(<Button variant="link">More</Button>);
+
+    const classes = screen.getByRole("button").className;
+    // The underline arrives on hover. A rule that underlined at rest would look
+    // like a link in a screenshot and read as one to `toContain("underline")`,
+    // which is why the resting state is asserted as an absence and the utility
+    // is matched whole — `hover:underline` and `underline-offset-4` both contain
+    // the substring.
+    expect(classes).toContain("hover:underline");
+    expect(classes).not.toMatch(/(^|\s)underline(\s|$)/);
+  });
+
+  it("hands back the height and padding a link button in prose cannot keep", () => {
+    render(
+      <Button variant="link" className={inlineLink}>
+        More
+      </Button>,
+    );
+
+    // `Button` merges `className` over `buttonVariants` with tailwind-merge, so
+    // this is the merge itself: canonical's `h-8 px-2.5` is gone from the
+    // rendered attribute rather than merely outranked by a later rule.
+    const classes = screen.getByRole("button").className.split(" ");
+    expect(classes).toContain("h-auto");
+    expect(classes).toContain("p-0");
+    expect(classes).not.toContain("h-8");
+    expect(classes).not.toContain("px-2.5");
+  });
+});
+
+describe("Alert and Badge", () => {
+  it("announces an alert, and composes its title and description", () => {
+    render(
+      <Alert variant="destructive">
+        <AlertTitle>Refused</AlertTitle>
+        <AlertDescription>because</AlertDescription>
+      </Alert>,
+    );
+    const alert = screen.getByRole("alert");
+    expect(alert.textContent).toContain("Refused");
+    expect(alert.textContent).toContain("because");
+  });
+
+  it("marks a badge with its variant, so a style can be keyed on data rather than colour", () => {
+    render(<Badge variant="success">done</Badge>);
+    expect(screen.getByText("done").getAttribute("data-variant")).toBe("success");
+    expect(screen.getByText("done").getAttribute("data-slot")).toBe("badge");
+  });
+
+  it.each(["success", "warning", "info", "quiet"] as const)("%s is a Badge variant keyed on data", (variant) => {
+    render(<Badge variant={variant}>x</Badge>);
+    const el = screen.getByText("x");
+    expect(el.getAttribute("data-variant")).toBe(variant);
+    expect(el.className).toContain("border-transparent");
+    expect(el.className).not.toMatch(/border-(emerald|amber|sky)/);
+  });
+});
+
+describe("fields", () => {
+  it("associates a label with its control by id", () => {
+    render(
+      <>
+        <Label htmlFor="tag">Tag</Label>
+        <Input id="tag" defaultValue="v1" />
+      </>,
+    );
+    expect(screen.getByLabelText("Tag")).toHaveProperty("value", "v1");
+  });
+
+  it("announces a field error", () => {
+    render(<FieldError>must not be blank</FieldError>);
+    expect(screen.getByRole("alert").textContent).toBe("must not be blank");
+  });
+});
+
+/**
+ * The two-line option — composed at the call site rather than a primitive prop,
+ * which is why what is asserted here is the trigger's own behaviour and not a
+ * layout this file would otherwise have to keep in step with a call site.
+ *
+ * The claim worth a test is the one that is easy to lose: the trigger shows the
+ * *same* two lines the list does, because Radix renders the selected item's own
+ * children into it. A second copy of the layout at the call site would look
+ * identical the day it was written and drift the day either half moved.
+ */
+describe("Select", () => {
+  function pickOne(): JSX.Element {
+    return (
+      <Select defaultValue="a">
+        <SelectTrigger data-testid="model" className={twoLineTrigger}>
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="a">
+            <span className="flex flex-col items-start">
+              <span>org/model-tiny</span>
+              <span className="text-xs text-muted-foreground">311.9 MB · tiny</span>
+            </span>
+          </SelectItem>
+          <SelectItem value="b">org/model-large</SelectItem>
+        </SelectContent>
+      </Select>
+    );
+  }
+
+  it("stacks the identifier and its meta in the closed trigger", () => {
+    render(pickOne());
+    const trigger = screen.getByTestId("model");
+    expect(trigger.textContent).toContain("org/model-tiny");
+    expect(trigger.textContent).toContain("311.9 MB · tiny");
+    // Two elements, not one line that happens to wrap — the meta carries the
+    // muted role and the id does not.
+    const meta = trigger.querySelector(".text-muted-foreground");
+    expect(meta?.textContent).toBe("311.9 MB · tiny");
+    expect(meta?.textContent).not.toContain("org/model-tiny");
+  });
+
+  it("grows rather than clipping, and leaves a one-line option where it was", () => {
+    render(pickOne());
+    // `h-8` would fix the height and squash the second line; `min-h-8` keeps the
+    // one-line control on Nova's contract height and lets a two-line one grow.
+    const trigger = screen.getByTestId("model");
+    expect(trigger.className).toContain("min-h-8");
+    // Nothing truncates: half a model id is not a model id.
+    expect(trigger.className).not.toContain("truncate");
+    // `twoLineTrigger` names canonical's own modifier chains, so `cn`'s merge
+    // replaces the fixed height and the value clamp rather than stacking beside
+    // them — a real check of the merge at render, not an echo of the constant.
+    expect(trigger.className).toContain("data-[size=default]:h-auto");
+    expect(trigger.className).toContain("line-clamp-none");
+    expect(trigger.className).not.toContain("data-[size=default]:h-8");
+    expect(trigger.className).not.toContain("line-clamp-1");
+  });
+
+  it("floors the open list at the closed control's width", async () => {
+    render(pickOne());
+    await userEvent.click(screen.getByTestId("model"));
+    const viewport = document.querySelector("[data-radix-select-viewport]");
+    expect(viewport).not.toBeNull();
+    const className = (viewport as HTMLElement).className;
+    expect(className).toContain("w-full");
+    expect(className).toContain("min-w-(--radix-select-trigger-width)");
+  });
+});
+
+describe("Card and Table", () => {
+  it("marks a card title with its slot, for the styling that reads it", () => {
+    render(
+      <Card>
+        <CardTitle>Classes</CardTitle>
+      </Card>,
+    );
+    expect(screen.getByText("Classes").getAttribute("data-slot")).toBe("card-title");
+  });
+
+  it("keeps the table's header while the body is empty", () => {
+    render(
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Name</TableHead>
+            <TableHead>State</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody />
+      </Table>,
+    );
+    expect(screen.getByRole("columnheader", { name: "Name" })).not.toBeNull();
+    expect(screen.getByRole("columnheader", { name: "State" })).not.toBeNull();
+  });
+});
+
+/**
+ * The tab bar, asserted on what it *means* rather than on what it looks like.
+ *
+ * The distinction between the open section and the other two has to survive a
+ * restyling, so nothing here matches a class string — a test that pinned
+ * `bg-card` would have failed on the very change it was supposed to protect, and
+ * a test that pinned `border-primary` would fail on the next one. What is asserted
+ * is the part a screen reader and the keyboard both read: the roles, `aria-selected`,
+ * Radix's `data-state`, and that only the open panel is in the tree at all.
+ *
+ * There is nothing here about a variant cascade: `TabsList` has one shape and no
+ * context to hand down.
+ */
+describe("Tabs", () => {
+  function bar(): JSX.Element {
+    return (
+      <Tabs defaultValue="schema">
+        <TabsList aria-label="Sections">
+          <TabsTrigger value="schema">Schema</TabsTrigger>
+          <TabsTrigger value="batches">Batches</TabsTrigger>
+        </TabsList>
+        <TabsContent value="schema">the classes</TabsContent>
+        <TabsContent value="batches">the batches</TabsContent>
+      </Tabs>
+    );
+  }
+
+  it("marks the open section as the selected tab and the others as not", () => {
+    render(bar());
+
+    const [schema, batches] = screen.getAllByRole("tab");
+    expect(schema.getAttribute("aria-selected")).toBe("true");
+    expect(schema.dataset.state).toBe("active");
+    expect(batches.getAttribute("aria-selected")).toBe("false");
+    expect(batches.dataset.state).toBe("inactive");
+  });
+
+  it("moves the selection when the tab is clicked, so the state is the source of the styling", async () => {
+    render(bar());
+
+    await userEvent.click(screen.getByRole("tab", { name: "Batches" }));
+    expect(screen.getByRole("tab", { name: "Batches" }).getAttribute("aria-selected")).toBe("true");
+    expect(screen.getByRole("tab", { name: "Schema" }).getAttribute("aria-selected")).toBe("false");
+  });
+
+  it("keeps only the open panel in the tree, and labels it with its tab", () => {
+    render(bar());
+
+    const panels = screen.getAllByRole("tabpanel");
+    expect(panels).toHaveLength(1);
+    expect(panels[0]?.textContent).toBe("the classes");
+    expect(screen.getByRole("tablist").getAttribute("aria-label")).toBe("Sections");
+  });
+
+  it("is operable from the keyboard, because every trigger is a real button", async () => {
+    render(bar());
+
+    // Radix's roving tabindex: one stop for the whole bar, arrows move within it.
+    await userEvent.tab();
+    expect(document.activeElement).toBe(screen.getByRole("tab", { name: "Schema" }));
+
+    await userEvent.keyboard("{ArrowRight}");
+    expect(document.activeElement).toBe(screen.getByRole("tab", { name: "Batches" }));
+    expect(screen.getByRole("tab", { name: "Batches" }).getAttribute("aria-selected")).toBe("true");
+  });
+});
+
+describe("Progress", () => {
+  it("reports its value to assistive technology, not only as a width", () => {
+    // Canonical `Progress` reads `value` only to size the indicator and never
+    // forwards it to Radix's `Root`, so `progressAria` says it again — every
+    // caller in the product spreads it beside `value` for exactly this reason.
+    render(<Progress value={42} {...progressAria(42)} aria-label="Ingest" />);
+    expect(screen.getByRole("progressbar", { name: "Ingest" }).getAttribute("aria-valuenow")).toBe(
+      "42",
+    );
+  });
+
+  it("fills with the functional colour, and carries the data-slot a caller can restyle from", () => {
+    // Canonical `Progress` has no `variant` prop and no notion of status — a
+    // batch's completion is an amount, not a polarity, so the indicator is
+    // always `bg-primary`. A caller who needs to reach it targets the
+    // `data-slot` it renders with, from its own `className` on `Root`.
+    render(<Progress value={42} aria-label="Ingest" />);
+    const fill = screen.getByRole("progressbar").firstElementChild as Element;
+    expect(fill.getAttribute("data-slot")).toBe("progress-indicator");
+    expect(fill.className).toBe("size-full flex-1 bg-primary transition-all");
+  });
+
+  it("hands its ref to the track element", () => {
+    let track: HTMLDivElement | null = null;
+    render(
+      <Progress
+        value={7}
+        aria-label="Ingest"
+        ref={(node) => {
+          track = node;
+        }}
+      />,
+    );
+    expect(track).toBe(screen.getByRole("progressbar"));
+  });
+});
+
+describe("Dialog", () => {
+  function describedBy(dialog: HTMLElement): readonly (string | null)[] {
+    return (dialog.getAttribute("aria-describedby") ?? "")
+      .split(" ")
+      .filter(Boolean)
+      .map((id) => document.getElementById(id)?.textContent ?? null);
+  }
+
+  it("points aria-describedby at every description, each under its own id, when the caller names them", () => {
+    render(
+      <Dialog open>
+        <DialogContent aria-describedby="d1 d2">
+          <DialogTitle>Narrowing</DialogTitle>
+          <DialogDescription id="d1">one class narrows</DialogDescription>
+          <DialogDescription id="d2">nothing becomes invalid</DialogDescription>
+        </DialogContent>
+      </Dialog>,
+    );
+    const dialog = screen.getByRole("dialog");
+    expect(dialog.getAttribute("aria-describedby")).toBe("d1 d2");
+    expect(describedBy(dialog)).toEqual(["one class narrows", "nothing becomes invalid"]);
+    expect(document.getElementById("d1")?.textContent).toBe("one class narrows");
+    expect(document.getElementById("d2")?.textContent).toBe("nothing becomes invalid");
+  });
+
+  it("wires a single, unnamed description through Radix's own id by default", () => {
+    render(
+      <Dialog open>
+        <DialogContent>
+          <DialogTitle>Narrowing</DialogTitle>
+          <DialogDescription>one class narrows</DialogDescription>
+        </DialogContent>
+      </Dialog>,
+    );
+    const dialog = screen.getByRole("dialog");
+    const describedById = dialog.getAttribute("aria-describedby");
+    expect(describedById).toBeTruthy();
+    expect(document.getElementById(describedById ?? "")?.textContent).toBe("one class narrows");
+  });
+});
+
+describe("sheet", () => {
+  it("renders a dialog with its title and description wired by Radix", async () => {
+    render(<Sheet open><SheetContent><SheetHeader><SheetTitle>Filters</SheetTitle><SheetDescription>Narrow the list</SheetDescription></SheetHeader></SheetContent></Sheet>);
+    const dialog = await screen.findByRole("dialog");
+    expect(dialog.getAttribute("data-slot")).toBe("sheet-content");
+    expect(dialog.getAttribute("data-side")).toBe("right");
+    expect(screen.getByRole("button", { name: "Close" })).toBeTruthy();
+  });
+});
+
+describe("DropdownMenu", () => {
+  it("sizes its surface to the items, not to the trigger", async () => {
+    const user = userEvent.setup();
+    render(
+      <DropdownMenu>
+        <DropdownMenuTrigger asChild>
+          <Button variant="ghost" size="icon" aria-label="Actions" />
+        </DropdownMenuTrigger>
+        <DropdownMenuContent className={menuSurface}>
+          <DropdownMenuItem>Check integrity of this connection</DropdownMenuItem>
+        </DropdownMenuContent>
+      </DropdownMenu>,
+    );
+    await user.click(screen.getByRole("button", { name: "Actions" }));
+    const classes = (await screen.findByRole("menu")).className.split(" ");
+    // Canonical pins the surface to the trigger with
+    // `w-(--radix-dropdown-menu-trigger-width)`, which behind this icon-sized
+    // button is the 128px floor — long items wrap. `menuSurface` is in the same
+    // utility group, so tailwind-merge drops canonical's at render and the
+    // rendered class list is the assertion: this is the merge, not a hope about
+    // cascade order.
+    expect(classes).toContain("w-auto");
+    expect(classes).not.toContain("w-(--radix-dropdown-menu-trigger-width)");
+    // The floor is a different group and survives, which is what keeps a
+    // one-word menu from collapsing to its widest item.
+    expect(classes).toContain("min-w-32");
+  });
+});

package/src/primitives/progress.tsx

@@ -0,0 +1,29 @@
+import * as React from "react"
+import { Progress as ProgressPrimitive } from "radix-ui"
+
+import { cn } from "../lib/cn.js"
+
+function Progress({
+  className,
+  value,
+  ...props
+}: React.ComponentProps<typeof ProgressPrimitive.Root>) {
+  return (
+    <ProgressPrimitive.Root
+      data-slot="progress"
+      className={cn(
+        "relative flex h-1 w-full items-center overflow-x-hidden rounded-full bg-muted",
+        className
+      )}
+      {...props}
+    >
+      <ProgressPrimitive.Indicator
+        data-slot="progress-indicator"
+        className="size-full flex-1 bg-primary transition-all"
+        style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
+      />
+    </ProgressPrimitive.Root>
+  )
+}
+
+export { Progress }

package/src/primitives/select.tsx

@@ -0,0 +1,190 @@
+import * as React from "react"
+import { Select as SelectPrimitive } from "radix-ui"
+
+import { cn } from "../lib/cn.js"
+import { ChevronDownIcon, CheckIcon, ChevronUpIcon } from "lucide-react"
+
+function Select({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Root>) {
+  return <SelectPrimitive.Root data-slot="select" {...props} />
+}
+
+function SelectGroup({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Group>) {
+  return (
+    <SelectPrimitive.Group
+      data-slot="select-group"
+      className={cn("scroll-my-1 p-1", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectValue({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Value>) {
+  return <SelectPrimitive.Value data-slot="select-value" {...props} />
+}
+
+function SelectTrigger({
+  className,
+  size = "default",
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+  size?: "sm" | "default"
+}) {
+  return (
+    <SelectPrimitive.Trigger
+      data-slot="select-trigger"
+      data-size={size}
+      className={cn(
+        "flex w-fit items-center justify-between gap-1.5 rounded-lg border border-input bg-transparent py-2 pr-2 pl-2.5 text-sm whitespace-nowrap transition-colors outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-placeholder:text-muted-foreground data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-1.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    >
+      {children}
+      <SelectPrimitive.Icon asChild>
+        <ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
+      </SelectPrimitive.Icon>
+    </SelectPrimitive.Trigger>
+  )
+}
+
+function SelectContent({
+  className,
+  children,
+  position = "item-aligned",
+  align = "center",
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Content>) {
+  return (
+    <SelectPrimitive.Portal>
+      <SelectPrimitive.Content
+        data-slot="select-content"
+        data-align-trigger={position === "item-aligned"}
+        className={cn("dark relative z-50 max-h-(--radix-select-content-available-height) min-w-36 origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[align-trigger=true]:animate-none 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 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95", 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}
+        align={align}
+        {...props}
+      >
+        <SelectScrollUpButton />
+        <SelectPrimitive.Viewport
+          data-position={position}
+          className={cn(
+            "data-[position=popper]:h-(--radix-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--radix-select-trigger-width)",
+            position === "popper" && ""
+          )}
+        >
+          {children}
+        </SelectPrimitive.Viewport>
+        <SelectScrollDownButton />
+      </SelectPrimitive.Content>
+    </SelectPrimitive.Portal>
+  )
+}
+
+function SelectLabel({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Label>) {
+  return (
+    <SelectPrimitive.Label
+      data-slot="select-label"
+      className={cn("px-1.5 py-1 text-xs text-muted-foreground", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectItem({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Item>) {
+  return (
+    <SelectPrimitive.Item
+      data-slot="select-item"
+      className={cn(
+        "relative flex w-full cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+        className
+      )}
+      {...props}
+    >
+      <span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center">
+        <SelectPrimitive.ItemIndicator>
+          <CheckIcon className="pointer-events-none" />
+        </SelectPrimitive.ItemIndicator>
+      </span>
+      <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+    </SelectPrimitive.Item>
+  )
+}
+
+function SelectSeparator({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Separator>) {
+  return (
+    <SelectPrimitive.Separator
+      data-slot="select-separator"
+      className={cn("pointer-events-none -mx-1 my-1 h-px bg-border", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectScrollUpButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>) {
+  return (
+    <SelectPrimitive.ScrollUpButton
+      data-slot="select-scroll-up-button"
+      className={cn(
+        "z-10 flex cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    >
+      <ChevronUpIcon
+      />
+    </SelectPrimitive.ScrollUpButton>
+  )
+}
+
+function SelectScrollDownButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>) {
+  return (
+    <SelectPrimitive.ScrollDownButton
+      data-slot="select-scroll-down-button"
+      className={cn(
+        "z-10 flex cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    >
+      <ChevronDownIcon
+      />
+    </SelectPrimitive.ScrollDownButton>
+  )
+}
+
+export {
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectScrollDownButton,
+  SelectScrollUpButton,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+}

package/src/primitives/separator.tsx

@@ -0,0 +1,28 @@
+"use client"
+
+import * as React from "react"
+import { Separator as SeparatorPrimitive } from "radix-ui"
+
+import { cn } from "../lib/cn.js"
+
+function Separator({
+  className,
+  orientation = "horizontal",
+  decorative = true,
+  ...props
+}: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
+  return (
+    <SeparatorPrimitive.Root
+      data-slot="separator"
+      decorative={decorative}
+      orientation={orientation}
+      className={cn(
+        "shrink-0 bg-border data-horizontal:h-px data-horizontal:w-full data-vertical:w-px data-vertical:self-stretch",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Separator }