# Order Detail

> The merchant’s page for one order: shipments, payment, customer and timeline. Handles partial fulfillment, holds, failed payments and cancellations.

Canonical: https://hextaui.com/blocks/order-detail
Last updated: 2026-10-29

## Overview

Order Detail is the page a merchant opens from the orders table: one order with everything they need to act on it. The header shows the order number, separate payment and fulfillment pills with a progress glyph (empty, half or full circle) so status never depends on color, the date and channel, the order actions and previous and next arrows.

The main column splits items by what happened to them. An Unfulfilled card lists what’s left to ship, worked out as purchased minus fulfilled minus refunded. Each shipment gets its own card with carrier, tracking link, delivery status and items, and refunded items get a Refunded card. The Payment card shows the total and only the lines that matter right now (refunded and net, an authorization with its expiry, or a balance due); subtotal, discounts, shipping, tax and currency conversion sit behind Breakdown. It has Capture payment for authorizations and Send invoice for pending or failed payments.

Fulfill items opens a sheet with a quantity stepper per line, capped at what’s left, a location, a tracking number that detects UPS, USPS, FedEx, DHL, Canada Post and Royal Mail from its pattern, and a Notify customer switch. Submitting closes the sheet and adds the shipment and a timeline event straight away. If onFulfill throws, both roll back and a toast offers Try again with the same choices.

The timeline reads like Shopify, Linear and Stripe activity feeds: a rail with one icon per event type (status color only on the icon), a short title built from the order data (“Payment of $564.41 captured”, “Shipped with UPS” with the tracking number linked), a muted second line and a relative time with the exact date in a tooltip. Day labels stick while you scroll. Customer emails fold into the event that sent them (“Customer emailed”, with Resend in Show details), three or more same-kind events in a row collapse into one line, and older history folds behind “Show N earlier events”. Comments are cards with avatar, author, edit and delete, and attachments as chips. Filter by All, Comments or System. The composer is one line until you focus it, then shows attachments, “Only visible to staff” and Post (⌘↵), and posts optimistically with retry. The right rail keeps to what matters: notes and tags only appear when they have content or can be edited, the customer card drops repeated name and phone lines, and conversion and risk show a one-line summary with details behind Show more. Cancelled, on hold, archived and loading states, and actions a staff member isn’t allowed to take, are all handled with a reason.

## Installation

### Step 1: Get HextaUI Pro

One payment unlocks every block, including future ones. [See pricing](https://hextaui.com/pricing).

### Step 2: Add the Pro registry to components.json

```json title="components.json"
{
  "registries": {
    "@hextaui-pro": {
      "url": "https://hextaui.com/r/pro/{name}.json",
      "headers": {
        "Authorization": "Bearer ${HEXTAUI_PRO_TOKEN}"
      }
    }
  }
}
```

### Step 3: Add your token

Create a token on your [account page](https://hextaui.com/account) and put it in `.env.local` as `HEXTAUI_PRO_TOKEN`.

### Step 4: Add the block

```bash
npx shadcn@latest add @hextaui-pro/order-detail
```

## Usage

### From the Shopify Admin API

Map an Admin API order to Order once, then pass onFulfill to call fulfillmentCreate with the quantities, tracking number and notify flag from the Fulfill items sheet. Throw the first userError and the new shipment rolls back with that message.

```tsx
"use client"

import * as React from "react"

import type { Fulfillment, FulfillmentStatus, Order, PaymentStatus } from "../order-status/order"
import { OrderDetail, OrderDetailSkeleton } from "@/components/blocks/order-detail/order-detail"
import type { FulfillmentDraft } from "@/components/blocks/order-detail/order-detail-utils"

type ShopifyMoney = { amount: string; currencyCode: string }

type ShopifyOrder = {
  id: string
  name: string
  createdAt: string
  email: string | null
  note: string | null
  tags: string[]
  cancelledAt: string | null
  displayFinancialStatus: string
  displayFulfillmentStatus: string
  sourceName: string | null
  currentSubtotalPriceSet: { presentmentMoney: ShopifyMoney }
  totalShippingPriceSet: { presentmentMoney: ShopifyMoney }
  totalTaxSet: { presentmentMoney: ShopifyMoney }
  totalPriceSet: { presentmentMoney: ShopifyMoney }
  lineItems: {
    nodes: {
      id: string
      title: string
      variantTitle: string | null
      sku: string | null
      quantity: number
      refundableQuantity: number
      unfulfilledQuantity: number
      image: { url: string; altText: string | null } | null
      originalUnitPriceSet: { presentmentMoney: ShopifyMoney }
      product: { id: string } | null
    }[]
  }
  fulfillmentOrders: { nodes: { id: string; status: string }[] }
}

const ORDER_QUERY = `#graphql
  query OrderDetail($id: ID!) {
    order(id: $id) {
      id name createdAt email note tags cancelledAt sourceName
      displayFinancialStatus displayFulfillmentStatus
      currentSubtotalPriceSet { presentmentMoney { amount currencyCode } }
      totalShippingPriceSet { presentmentMoney { amount currencyCode } }
      totalTaxSet { presentmentMoney { amount currencyCode } }
      totalPriceSet { presentmentMoney { amount currencyCode } }
      lineItems(first: 50) {
        nodes {
          id title variantTitle sku quantity refundableQuantity unfulfilledQuantity
          image { url altText }
          originalUnitPriceSet { presentmentMoney { amount currencyCode } }
          product { id }
        }
      }
      fulfillmentOrders(first: 10) { nodes { id status } }
    }
  }
`

const FULFILL_MUTATION = `#graphql
  mutation Fulfill($fulfillment: FulfillmentInput!) {
    fulfillmentCreate(fulfillment: $fulfillment) {
      fulfillment { id status createdAt trackingInfo { company number url } }
      userErrors { field message }
    }
  }
`

const payment: Record<string, PaymentStatus> = {
  PENDING: "pending",
  AUTHORIZED: "authorized",
  PAID: "paid",
  PARTIALLY_PAID: "partially_paid",
  PARTIALLY_REFUNDED: "partially_refunded",
  REFUNDED: "refunded",
  VOIDED: "voided",
}

const fulfillment: Record<string, FulfillmentStatus> = {
  UNFULFILLED: "unfulfilled",
  PARTIALLY_FULFILLED: "partially_fulfilled",
  FULFILLED: "fulfilled",
  ON_HOLD: "on_hold",
  SCHEDULED: "scheduled",
}

async function admin<T>(query: string, variables: Record<string, unknown>): Promise<T> {
  const response = await fetch("/api/shopify/admin", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ query, variables }),
  })
  const { data, errors } = (await response.json()) as { data: T; errors?: { message: string }[] }
  if (errors?.length) throw new Error(errors[0].message)
  return data
}

function fromShopify(order: ShopifyOrder): Order {
  return {
    id: order.id,
    name: order.name,
    createdAt: order.createdAt,
    email: order.email ?? undefined,
    note: order.note ?? undefined,
    tags: order.tags,
    cancelledAt: order.cancelledAt ?? undefined,
    channel: order.sourceName ?? undefined,
    currencyCode: order.totalPriceSet.presentmentMoney.currencyCode,
    subtotal: order.currentSubtotalPriceSet.presentmentMoney,
    shipping: order.totalShippingPriceSet.presentmentMoney,
    tax: order.totalTaxSet.presentmentMoney,
    total: order.totalPriceSet.presentmentMoney,
    discounts: [],
    paymentStatus: payment[order.displayFinancialStatus] ?? "pending",
    fulfillmentStatus: fulfillment[order.displayFulfillmentStatus] ?? "unfulfilled",
    lines: order.lineItems.nodes.map((line) => ({
      id: line.id,
      productId: line.product?.id,
      title: line.title,
      variantTitle: line.variantTitle ?? undefined,
      sku: line.sku ?? undefined,
      image: line.image
        ? { id: line.image.url, src: line.image.url, alt: line.image.altText ?? line.title }
        : undefined,
      quantity: line.quantity,
      price: line.originalUnitPriceSet.presentmentMoney,
      refundedQuantity: line.quantity - line.refundableQuantity,
      fulfilledQuantity: line.refundableQuantity - line.unfulfilledQuantity,
    })),
    fulfillments: [],
    refunds: [],
    events: [],
  }
}

export function ShopifyOrderPage({ orderId }: { orderId: string }) {
  const [order, setOrder] = React.useState<Order | null>(null)
  const [fulfillmentOrderId, setFulfillmentOrderId] = React.useState<string>()

  const load = React.useCallback(async () => {
    const data = await admin<{ order: ShopifyOrder }>(ORDER_QUERY, { id: orderId })
    setOrder(fromShopify(data.order))
    setFulfillmentOrderId(data.order.fulfillmentOrders.nodes.find((item) => item.status === "OPEN")?.id)
  }, [orderId])

  React.useEffect(() => {
    void load()
  }, [load])

  const fulfill = async (_: Order, draft: FulfillmentDraft): Promise<Fulfillment | void> => {
    if (!fulfillmentOrderId) throw new Error("This order has no open fulfillment order.")
    const data = await admin<{
      fulfillmentCreate: { userErrors: { message: string }[] }
    }>(FULFILL_MUTATION, {
      fulfillment: {
        notifyCustomer: draft.notifyCustomer,
        trackingInfo: draft.trackingNumber
          ? { number: draft.trackingNumber, company: draft.carrier || undefined }
          : undefined,
        lineItemsByFulfillmentOrder: [{ fulfillmentOrderId }],
      },
    })
    const error = data.fulfillmentCreate.userErrors[0]
    if (error) throw new Error(error.message)
    await load()
  }

  if (!order) return <OrderDetailSkeleton />

  return (
    <OrderDetail
      order={order}
      timeZone="America/New_York"
      backHref="/orders"
      onFulfill={fulfill}
    />
  )
}
```

### Post timeline comments

onComment gets the message and attached files from the one-line composer (it expands on focus, ⌘↵ posts). The comment card shows right away, dimmed, and turns into a failed state with Retry when the request throws. Return the saved OrderEvent so edits and deletes use your id; onResendEmail adds Resend inside an event’s Show details.

```tsx
"use client"

import type { Order, OrderEvent } from "../order-status/order"
import { OrderDetail } from "@/components/blocks/order-detail/order-detail"

type Staff = { id: string; name: string; avatar?: string }

async function send<T>(url: string, method: string, body?: unknown): Promise<T> {
  const response = await fetch(url, {
    method,
    headers: { "content-type": "application/json" },
    body: body === undefined ? undefined : JSON.stringify(body),
  })
  if (!response.ok) {
    const problem = (await response.json().catch(() => null)) as { detail?: string } | null
    throw new Error(problem?.detail ?? "Couldn’t reach the server. Try again.")
  }
  return (await response.json()) as T
}

export function OrderWithComments({ order, staff }: { order: Order; staff: Staff }) {
  const base = `/api/orders/${encodeURIComponent(order.id)}/comments`

  return (
    <OrderDetail
      order={order}
      currentUser={{ name: staff.name, avatar: staff.avatar }}
      onComment={async ({ message, attachments }) => {
        const form = new FormData()
        form.set("message", message)
        for (const file of attachments) form.append("files", file)
        const response = await fetch(base, { method: "POST", body: form })
        if (!response.ok) throw new Error("Your comment wasn’t saved. Try again.")
        return (await response.json()) as OrderEvent
      }}
      onEditComment={(event, message) =>
        send<OrderEvent>(`${base}/${event.id}`, "PATCH", { message })
      }
      onDeleteComment={(event) => send(`${base}/${event.id}`, "DELETE")}
      onResendEmail={(event) =>
        send(`/api/orders/${encodeURIComponent(order.id)}/emails/resend`, "POST", { eventId: event.id })
      }
    />
  )
}
```

### A Stripe charge in the payment card

Read a Stripe charge into paymentStatus, the card label, amountPaid and a failed-payment event. When the balance transaction settles in another currency, pass shopCurrency and the card adds the converted total and net payment.

```tsx
import { fromMinorUnits, toMinorUnits } from "../price/money"
import type { Order, PaymentStatus } from "../order-status/order"

type StripeCharge = {
  id: string
  amount: number
  amount_captured: number
  amount_refunded: number
  currency: string
  captured: boolean
  status: "succeeded" | "pending" | "failed"
  failure_message: string | null
  created: number
  payment_method_details: { card?: { brand: string; last4: string } } | null
  balance_transaction: { amount: number; currency: string; exchange_rate: number | null } | null
}

function paymentStatus(charge: StripeCharge): PaymentStatus {
  if (charge.status === "failed") return "failed"
  if (charge.status === "pending") return "pending"
  if (!charge.captured) return "authorized"
  if (charge.amount_refunded >= charge.amount_captured) return "refunded"
  if (charge.amount_refunded > 0) return "partially_refunded"
  return "paid"
}

export function withStripeCharge(order: Order, charge: StripeCharge) {
  const currency = charge.currency.toUpperCase()
  const card = charge.payment_method_details?.card
  const next: Order = {
    ...order,
    paymentStatus: paymentStatus(charge),
    paymentMethod: card
      ? {
          brand: card.brand,
          last4: card.last4,
          label: `${card.brand[0].toUpperCase()}${card.brand.slice(1)} ending in ${card.last4}`,
        }
      : order.paymentMethod,
    events: charge.failure_message
      ? [
          ...order.events,
          {
            id: `${charge.id}-failed`,
            type: "payment_failed",
            at: new Date(charge.created * 1000).toISOString(),
            message: `${card ? `Card ending in ${card.last4}` : "The payment"} was declined: ${charge.failure_message}.`,
          },
        ]
      : order.events,
  }
  const settlement = charge.balance_transaction
  return {
    order: next,
    amountPaid: fromMinorUnits(charge.amount_captured, currency),
    shopCurrency:
      settlement && settlement.currency.toUpperCase() !== currency && settlement.exchange_rate
        ? { currencyCode: settlement.currency.toUpperCase(), rate: settlement.exchange_rate }
        : undefined,
    capturable: charge.captured ? null : fromMinorUnits(charge.amount, currency),
    matchesOrder: toMinorUnits(order.total) === charge.amount,
  }
}
```

## Anatomy

The parts you compose, from the outside in.

| Part | Description |
| --- | --- |
| `OrderDetail` | The whole page: header, banners, item cards, payment card, timeline and right rail. |
| `OrderDetailSkeleton` | The loading layout, also shown when loading is true. |
| `FulfillItemsSheet` | The sheet that picks quantities, location, tracking and notification for a new shipment. |
| `OrderTimeline` | The one-line composer, the All / Comments / System filter and the day-grouped rail of events and comment cards. |
| `NotesCard, CustomerCard, ConversionCard, RiskCard, TagsCard` | The right rail cards, usable on their own. |
| `orderActionState, paymentSummary, lineQuantities, detectCarrier, applyFulfillment` | Pure helpers for action availability with reasons, payment totals, remaining quantities, carrier detection and optimistic shipments. |

## API reference

### OrderDetail

Also takes div props. Every callback may return a promise; throw to show the message where the action happened.

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `order` | `Order` | – | The order, from ../order-status/order. Pass a new object when it changes; local optimistic state resets to it. |
| `loading` | `boolean` | `false` | Shows OrderDetailSkeleton. |
| `locale` | `string` | `"en-US"` | Locale for dates, money and plurals. |
| `timeZone` | `string` | `"UTC"` | The shop’s time zone for dates and day groups. |
| `now` | `string` | – | An ISO time for Today and Yesterday labels and the authorization countdown. New events are stamped from it. |
| `currentUser` | `{ name: string; avatar?: string }` | – | The staff member. Their comments can be edited and deleted. |
| `permissions` | `Partial<Record<OrderDetailAction, boolean \| string>>` | – | false or a reason string disables that action with a tooltip, such as { refund: "Only admins can refund orders." }. |
| `archived` | `boolean` | – | Shows the archived banner and badge. |
| `holdReason` | `string` | – | Text for the on hold banner. Defaults to the latest hold note on the order. |
| `risk` | `OrderRiskAnalysis` | – | Level, headline, indicators with good, bad or neutral tone, IP and provider. Defaults to order.risk. |
| `conversion` | `{ channel?; source?; firstVisit?; sessions?; landingPage? }` | – | Visit details for the conversion summary. |
| `shopCurrency` | `{ currencyCode: string; rate: number }` | – | When it differs from the order currency, the payment card adds the total and net in the shop currency. |
| `amountPaid` | `Money` | – | What the customer has paid, for partially paid orders. |
| `locations` | `string[]` | – | Locations for the Fulfill items sheet. Defaults to the locations of existing shipments. |
| `backHref, onBack` | `string, () => void` | – | The back arrow. |
| `customerHref` | `string` | – | Link for the customer’s name. |
| `previousOrder, nextOrder` | `{ name: string; href?: string } \| null` | – | The neighbors for the arrows and J/K. |
| `onNavigate` | `(direction: "previous" \| "next") => void` | – | Called by the arrows and by J and K. |
| `onRefund, onReturn, onEdit` | `(order: Order) => void` | – | Header actions. Wire onRefund to the Refund block’s sheet. |
| `onDuplicate, onPrintPackingSlip` | `(order: Order) => Awaitable` | – | More menu actions. |
| `onCancel` | `(order, { reason, restock, notifyCustomer }) => Awaitable` | – | Confirmed in a dialog that explains what happens to the payment. The dialog stays open and shows the error if it throws. |
| `onArchiveChange` | `(order, archived: boolean) => Awaitable` | – | Archive and unarchive, optimistic with Undo. |
| `onFulfill` | `(order, draft: FulfillmentDraft) => Awaitable<Fulfillment \| void>` | – | Creates a shipment. Return the saved Fulfillment to replace the optimistic one. |
| `onCapturePayment, onSendInvoice, onReleaseHold` | `(order: Order) => Awaitable` | – | Payment and hold actions. |
| `onComment` | `({ message, attachments }) => Awaitable<OrderEvent \| void>` | – | Posts a comment. Return the saved event. |
| `onEditComment, onDeleteComment` | `(event, message?) => Awaitable` | – | Edit and delete your own comments. Delete waits for the Undo toast to close. |
| `onResendEmail` | `(event: OrderEvent) => Awaitable` | – | Shows Resend on email events. |
| `onNoteChange, onTagsChange` | `(note: string) / (tags: string[]) => Awaitable` | – | Saved optimistically and reverted with a message if they throw. Omit to make them read-only. |
| `labels` | `Partial<OrderDetailLabels>` | – | Words for the actions and buttons. |

### OrderTimeline

Usable on its own for customers, drafts or inventory history.

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `order` | `Order` | – | The order whose events, fulfillments and refunds the titles are built from. |
| `currentUser` | `{ name: string; avatar?: string }` | – | The signed-in staff member. Their comments get Edit and Delete. |
| `defaultFilter` | `"all" \| "comments" \| "system"` | – | The filter selected on first render. Defaults to "all". |
| `visibleCount` | `number` | – | How many entries show before older history folds behind “Show N earlier events”. Comments-only view never folds. Defaults to 6. |
| `now` | `string \| null` | – | ISO time used for relative times (“2 hr. ago”) and Today / Yesterday labels. Without it, times show as clock times. |
| `commentState` | `{ available: boolean; reason?: string }` | – | Disables the composer and explains why. |
| `onComment, onEditComment, onDeleteComment` | `async callbacks` | – | Comment posting is optimistic with Retry and Discard on failure; delete has a 5 second Undo toast. |
| `onResendEmail` | `(event: OrderEvent) => Awaitable` | – | Adds Resend next to each email inside Show details. |

### FulfillmentDraft

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `lines` | `{ lineId: string; quantity: number }[]` | – | Quantities to ship, each at most the line’s remaining quantity. |
| `locationName` | `string` | – | The location it ships from. |
| `trackingNumber` | `string` | – | Optional tracking number. |
| `carrier` | `string` | – | The chosen carrier, or empty to use the detected one. |
| `notifyCustomer` | `boolean` | – | Send a shipping confirmation. |

### orderActionState

(order, action, { permissions, archived }) => { available, reason }

| Prop | Type | Default | Description |
| --- | --- | --- | --- |
| `action` | `"refund" \| "return" \| "edit" \| "duplicate" \| "cancel" \| "archive" \| "print" \| "fulfill" \| "capture" \| "invoice" \| "releaseHold" \| "comment"` | – | Returns why an action isn’t available, such as “Items have shipped. Refund or return them instead.” |

## Keyboard

| Key | Action |
| --- | --- |
| `J` | Opens the next order when focus isn’t in a field. |
| `K` | Opens the previous order. |
| `Meta` `Enter` | Posts the comment, or saves a comment or note you’re editing. |
| `Escape` | Cancels a comment or note edit and closes sheets, dialogs and menus. |
| `ArrowUp` `ArrowDown` | Change a quantity in the Fulfill items sheet. |
| `Backspace` | In an empty tag field, removes the last tag. |
| `Escape` | In an empty comment composer, leaves it so it folds back to one line. |

## Accessibility

- Status pills pair words with a progress glyph, so payment, fulfillment and shipment states never rely on color. The risk meter is a meter with a text value.
- Disabled actions stay focusable, show their reason in a tooltip and link it with aria-describedby. Disabled menu items show the reason under the label.
- A polite live region announces fulfillments, comments, holds released and archive changes, and failures. Comment and note errors use role="alert" next to the item.
- Every card is a labelled section and the page has one h1. The timeline is an ordered list per day; each event reads as one sentence (title, details, then the full date from a time element), icons are hidden from screen readers, Show details buttons name their event and report expanded state, and comments are articles labelled with their author. Copy buttons announce “Copied to clipboard” and tracking and map links say they open a new tab.

## Built with

The free HextaUI components Order Detail is made from. Each one installs on its own.

- [Alert](https://hextaui.com/docs/alert) - Inline messages for status and feedback, with a neutral surface, a colored icon and a dismiss that collapses smoothly.
- [Alert dialog](https://hextaui.com/docs/alert-dialog) - A confirmation dialog for destructive or important actions that waits for async work, and becomes a bottom sheet on phones.
- [Avatar](https://hextaui.com/docs/avatar) - User photos with an initials fallback, status badges and stacked groups that collapse into a count.
- [Badge](https://hextaui.com/docs/badge) - Status labels with colored dots, removable tags that slide closed and counts that roll to their new value.
- [Button](https://hextaui.com/docs/button) - Buttons in every variant and size, with a built-in loading, success and error flow that skips the spinner for fast requests.
- [Button group](https://hextaui.com/docs/button-group) - Buttons joined into one control, with shared seams, separators, text addons, nesting and vertical stacks.
- [Card](https://hextaui.com/docs/card) - A surface for grouping content, with three variants, edge-to-edge media, concentric radii and whole-card links.
- [Collapsible](https://hextaui.com/docs/collapsible) - A panel that shows and hides with height motion you can reverse mid-way, without jumping the layout.
- [Dropdown menu](https://hextaui.com/docs/dropdown-menu) - A menu of actions and options behind a button, with groups, submenus, checkbox and radio items, and shortcuts.
- [Field](https://hextaui.com/docs/field) - Labels, descriptions and errors wired to their control, with validation states and layouts for forms.
- [Input](https://hextaui.com/docs/input) - A text input with three sizes, invalid and read-only states, native validation styling and a 16px touch font so phones never zoom in.
- [Input group](https://hextaui.com/docs/input-group) - An input with icons, text, buttons or a keyboard hint attached, sharing one border and focus ring.
- [Kbd](https://hextaui.com/docs/kbd) - Key caps for shortcuts that show the right symbols on every platform, read them out properly and press down with the real keys.
- [Select](https://hextaui.com/docs/select) - Pick one or more options from a list that opens on the current value, with typeahead, groups and form support.
- [Separator](https://hextaui.com/docs/separator) - A hairline that divides content horizontally or vertically, with an optional label and a decorative mode for purely visual lines.
- [Sheet](https://hextaui.com/docs/sheet) - A panel that slides in from any edge, with swipe-to-dismiss, scroll lock and stacked nesting.
- [Skeleton](https://hextaui.com/docs/skeleton) - Placeholders that wait 150ms before showing, take the exact size of the content they wrap, and fade it in without moving anything.
- [Spinner](https://hextaui.com/docs/spinner) - A loading indicator with Apple-style ticks or a breathing ring that can wait before showing and stay long enough not to flicker.
- [Switch](https://hextaui.com/docs/switch) - An on/off toggle you can tap, press or drag, with a thumb that stretches under your finger and an optional pending state for saves.
- [Textarea](https://hextaui.com/docs/textarea) - Multi-line text that grows smoothly with what you write between a minimum and maximum number of rows, with counters, validation and a submit shortcut.
- [Toast](https://hextaui.com/docs/toast) - Brief messages that stack neatly, expand on hover, swipe away, and turn a loading state into success or error in place.
- [Toggle group](https://hextaui.com/docs/toggle-group) - A row of toggles for one choice or many, with a fill that slides to the picked item, joined or spaced items and arrow-key focus.
- [Tooltip](https://hextaui.com/docs/tooltip) - A short hint on hover or keyboard focus that opens after a brief rest, switches instantly between neighbours and shows shortcuts.

## Code

9 files, added to components/blocks/order-detail.
