# Carousel

shadcn carousel reskinned for UI95.

Source: https://www.ui95.dev/ui/carousel

## Examples

```tsx
import {
  Carousel,
  CarouselContent,
  CarouselItem,
  CarouselNext,
  CarouselPrevious,
} from "@/components/ui/carousel"

import type { ShowcaseDemo } from "../types"

const SLIDES = ["DISK 1", "DISK 2", "DISK 3", "DISK 4", "DISK 5"] as const

function Slide({ label }: { label: string }) {
  return (
    <div className="flex aspect-square items-center justify-center pixel-border border-border bg-card font-pixel text-[24px] leading-none uppercase">
      {label}
    </div>
  )
}

export const demo: ShowcaseDemo = {
  span: "wide",
  variants: [
    {
      label: "horizontal",
      render: () => (
        <Carousel className="mx-12 w-full max-w-48 self-center">
          <CarouselContent>
            {SLIDES.map((label) => (
              <CarouselItem key={label}>
                <Slide label={label} />
              </CarouselItem>
            ))}
          </CarouselContent>
          <CarouselPrevious />
          <CarouselNext />
        </Carousel>
      ),
    },
    {
      label: "vertical",
      render: () => (
        <Carousel orientation="vertical" className="my-12 w-full max-w-40 self-center">
          <CarouselContent className="h-44">
            {SLIDES.map((label) => (
              <CarouselItem key={label}>
                <Slide label={label} />
              </CarouselItem>
            ))}
          </CarouselContent>
          <CarouselPrevious />
          <CarouselNext />
        </Carousel>
      ),
    },
  ],
}
```

## Installation

```bash
npx shadcn@latest add https://www.ui95.dev/r/carousel.json
```

Run it in a Radix shadcn project that already has the UI95 theme.

Dependencies:

```bash
npm install cn embla-carousel-react
```

Add these items first:

- [button](https://www.ui95.dev/ui/button)
- [pixel-glyphs](https://www.ui95.dev/ui/pixel-glyphs)

`components/ui/carousel.tsx`

```tsx
"use client"

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

import { Button } from "@/components/ui/button"
import { ChevronGlyph } from "@/components/ui/pixel-glyphs"

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
}

function Carousel({
  orientation = "horizontal",
  opts,
  setApi,
  plugins,
  className,
  children,
  ...props
}: React.ComponentProps<"div"> & CarouselProps) {
  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(true)
  }, [api])

  const scrollNext = React.useCallback(() => {
    api?.scrollNext(true)
  }, [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
    const frame = requestAnimationFrame(() => onSelect(api))
    api.on("reInit", onSelect)
    api.on("select", onSelect)

    return () => {
      cancelAnimationFrame(frame)
      api.off("reInit", onSelect)
      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
        onKeyDownCapture={handleKeyDown}
        className={cn("relative", className)}
        role="region"
        aria-roledescription="carousel"
        data-slot="carousel"
        {...props}
      >
        {children}
      </div>
    </CarouselContext.Provider>
  )
}

function CarouselContent({ className, ...props }: React.ComponentProps<"div">) {
  const { carouselRef, orientation } = useCarousel()

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

function CarouselItem({ className, ...props }: React.ComponentProps<"div">) {
  const { orientation } = useCarousel()

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

function CarouselPrevious({
  className,
  variant = "outline",
  size = "icon-sm",
  ...props
}: React.ComponentProps<typeof Button>) {
  const { orientation, scrollPrev, canScrollPrev } = useCarousel()

  return (
    <Button
      data-slot="carousel-previous"
      variant={variant}
      size={size}
      className={cn(
        "absolute touch-manipulation",
        orientation === "horizontal"
          ? "inset-y-0 -left-12 my-auto"
          : "inset-x-0 -top-12 mx-auto",
        className
      )}
      disabled={!canScrollPrev}
      onClick={scrollPrev}
      {...props}
    >
      <ChevronGlyph
        direction={orientation === "horizontal" ? "left" : "up"}
        className={orientation === "horizontal" ? "cn-rtl-flip" : undefined}
      />
      <span className="sr-only">Previous slide</span>
    </Button>
  )
}

function CarouselNext({
  className,
  variant = "outline",
  size = "icon-sm",
  ...props
}: React.ComponentProps<typeof Button>) {
  const { orientation, scrollNext, canScrollNext } = useCarousel()

  return (
    <Button
      data-slot="carousel-next"
      variant={variant}
      size={size}
      className={cn(
        "absolute touch-manipulation",
        orientation === "horizontal"
          ? "inset-y-0 -right-12 my-auto"
          : "inset-x-0 -bottom-12 mx-auto",
        className
      )}
      disabled={!canScrollNext}
      onClick={scrollNext}
      {...props}
    >
      <ChevronGlyph
        direction={orientation === "horizontal" ? "right" : "down"}
        className={orientation === "horizontal" ? "cn-rtl-flip" : undefined}
      />
      <span className="sr-only">Next slide</span>
    </Button>
  )
}

export {
  Carousel,
  type CarouselApi,
  CarouselContent,
  CarouselItem,
  CarouselNext,
  CarouselPrevious,
  useCarousel,
}
```

## API reference

### Carousel

| Prop | Type | Default |
| --- | --- | --- |
| `opts` | `Partial<import("/vercel/path0/node_modules/embla-carousel/esm/components/Options").OptionsType>` | - |
| `plugins` | `import("/vercel/path0/node_modules/embla-carousel/esm/index").CreatePluginType<import("/vercel/path0/node_modules/embla-carousel/esm/components/Plugins").LoosePluginType, {}>[]` | - |
| `orientation` | `"vertical" \| "horizontal"` | `"horizontal"` |
| `setApi` | `((api: CarouselApi) => void)` | - |

### CarouselContent

No props of its own. It forwards the props of the element or primitive it wraps.

### CarouselItem

No props of its own. It forwards the props of the element or primitive it wraps.

### CarouselNext

| Prop | Type | Default |
| --- | --- | --- |
| `variant` | `"link" \| "default" \| "outline" \| "secondary" \| "ghost" \| "destructive"` | `"outline"` |
| `size` | `"sm" \| "lg" \| "default" \| "xs" \| "icon" \| "icon-xs" \| "icon-sm" \| "icon-lg"` | `"icon-sm"` |
| `asChild` | `boolean` | - |

### CarouselPrevious

| Prop | Type | Default |
| --- | --- | --- |
| `variant` | `"link" \| "default" \| "outline" \| "secondary" \| "ghost" \| "destructive"` | `"outline"` |
| `size` | `"sm" \| "lg" \| "default" \| "xs" \| "icon" \| "icon-xs" \| "icon-sm" \| "icon-lg"` | `"icon-sm"` |
| `asChild` | `boolean` | - |
