Enterprise hero

import Link from 'next/link'
import { ArrowRight, Lock, ShieldCheck, FileCheck2 } from 'lucide-react'
import { ButtonLink } from '@/components/ui/button'
import { Container } from '@/components/ui/layout'

/**
 * Enterprise header
 *
 * Two actions of equal weight — "talk to sales" and "read the security brief"
 * — because enterprise buyers arrive with two different jobs. The assurance
 * strip below carries the certifications that would otherwise be buried three
 * clicks deep.
 */
const assurances = [
  { icon: ShieldCheck, label: 'SOC 2 Type II', detail: 'Audited annually' },
  { icon: Lock, label: 'SSO & SCIM', detail: 'Okta, Entra, Google' },
  { icon: FileCheck2, label: 'DPA available', detail: 'EU and UK residency' },
]

export default function EnterpriseHeader() {
  return (
    <header className="border-b border-line bg-canvas">
      <Container className="py-section">
        <div className="grid gap-10 lg:grid-cols-[1.15fr_1fr] lg:items-center lg:gap-16">
          <div>
            <p className="label-caps text-ink-subtle">For organisations</p>
            <h1 className="display-type mt-4 text-3xl leading-tight font-semibold text-ink-strong sm:text-4xl lg:text-5xl">
              A design system your security review will actually pass.
            </h1>
            <p className="mt-5 max-w-xl text-md text-ink-muted">
              Self-hosted, no telemetry, no third-party runtime. Everything ships as source you own
              and can audit.
            </p>
            <div className="mt-8 flex flex-wrap gap-3">
              <ButtonLink
                href="/forms/sales-inquiry"
                size="lg"
                trailingIcon={<ArrowRight className="size-4" />}
              >
                Talk to sales
              </ButtonLink>
              <ButtonLink href="/docs/installation" size="lg" variant="outline">
                Read the technical brief
              </ButtonLink>
            </div>
          </div>

          <dl className="flex flex-col divide-y divide-[var(--color-border-subtle)] rounded-xl border border-line bg-surface">
            {assurances.map((item) => {
              const Icon = item.icon
              return (
                <div key={item.label} className="flex items-start gap-3.5 p-5">
                  <span className="mt-0.5 flex size-9 shrink-0 items-center justify-center rounded-md bg-accent-soft text-accent-soft-ink">
                    <Icon className="size-4.5" aria-hidden="true" />
                  </span>
                  <div>
                    <dt className="text-sm font-semibold text-ink-strong">{item.label}</dt>
                    <dd className="mt-0.5 text-xs text-ink-muted">{item.detail}</dd>
                  </div>
                </div>
              )
            })}
          </dl>
        </div>
      </Container>

      <div className="border-t border-line bg-surface-sunken">
        <Container className="flex flex-wrap items-center justify-between gap-3 py-4">
          <p className="text-sm text-ink-muted">
            Procurement questions? We answer security questionnaires in five working days.
          </p>
          <Link
            href="/forms/quote-request"
            className="text-sm font-medium text-accent underline underline-offset-4"
          >
            Request a quote
          </Link>
        </Container>
      </div>
    </header>
  )
}

import type { ButtonHTMLAttributes, ReactNode } from 'react'
import Link from 'next/link'
import { cn } from '@/lib/cn'
import { variants } from '@/lib/variants'
import { Spinner } from './spinner'

/**
 * Button
 *
 * The whole action surface of Foundry in one component. It is intentionally a
 * *shared* component (no `'use client'`): rendered from a Server Component it
 * ships zero JavaScript, and it upgrades to a client island automatically when
 * a Client Component imports it.
 *
 * Height, padding and radius resolve from density and radius tokens, so a
 * button restyles itself when the density or palette axis changes. Focus is
 * handled once, globally, by the `:focus-visible` rule in `globals.css`.
 */
const buttonVariants = variants(
  cn(
    'relative inline-flex items-center justify-center gap-2 whitespace-nowrap font-medium',
    'transition-colors duration-150 ease-standard select-none',
    'disabled:pointer-events-none disabled:opacity-50',
    'aria-disabled:pointer-events-none aria-disabled:opacity-50',
  ),
  {
    variants: {
      variant: {
        primary: 'bg-accent text-accent-ink hover:bg-accent-hover active:bg-accent-active',
        secondary: 'bg-surface-inverse text-ink-inverse hover:opacity-90 active:opacity-80',
        outline: 'border border-line-strong bg-surface text-ink hover:bg-surface-sunken',
        ghost: 'text-ink hover:bg-surface-sunken active:bg-surface-sunken',
        destructive: 'bg-danger text-white hover:opacity-90 active:opacity-80',
        success: 'bg-success text-white hover:opacity-90 active:opacity-80',
        warning: 'bg-warning text-white hover:opacity-90 active:opacity-80',
        link: 'text-accent underline underline-offset-4 hover:text-accent-hover',
        soft: 'bg-accent-soft text-accent-soft-ink border border-accent-line hover:brightness-[0.97]',
      },
      size: {
        sm: 'h-control-sm px-3 text-xs rounded-md',
        md: 'h-control px-[var(--density-control-padding-x)] text-sm rounded-md',
        lg: 'h-control-lg px-5 text-base rounded-md',
        icon: 'h-control w-control p-0 rounded-md',
        'icon-sm': 'h-control-sm w-control-sm p-0 rounded-sm',
      },
      block: { true: 'w-full', false: '' },
    },
    defaultVariants: { variant: 'primary', size: 'md', block: false },
    compound: [
      { variant: 'link', size: 'sm', class: 'h-auto px-0' },
      { variant: 'link', size: 'md', class: 'h-auto px-0' },
      { variant: 'link', size: 'lg', class: 'h-auto px-0' },
    ],
  },
)

export type ButtonVariant =
  | 'primary'
  | 'secondary'
  | 'outline'
  | 'ghost'
  | 'destructive'
  | 'success'
  | 'warning'
  | 'link'
  | 'soft'

export type ButtonSize = 'sm' | 'md' | 'lg' | 'icon' | 'icon-sm'

export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
  variant?: ButtonVariant
  size?: ButtonSize
  block?: boolean
  /** Swaps content for a spinner while preserving the button's measured width. */
  loading?: boolean
  /** Announced by assistive tech while `loading` is true. */
  loadingLabel?: string
  leadingIcon?: ReactNode
  trailingIcon?: ReactNode
}

export function Button({
  variant = 'primary',
  size = 'md',
  block = false,
  loading = false,
  loadingLabel = 'Working',
  leadingIcon,
  trailingIcon,
  className,
  children,
  disabled,
  type = 'button',
  ...props
}: ButtonProps) {
  return (
    <button
      type={type}
      className={buttonVariants({ variant, size, block, className })}
      disabled={disabled ?? loading}
      aria-busy={loading || undefined}
      {...props}
    >
      {loading ? (
        <>
          {/* Label stays in the DOM but hidden so the control never collapses
              to spinner width halfway through an interaction. */}
          <span className="invisible flex items-center gap-2" aria-hidden="true">
            {leadingIcon}
            {children}
            {trailingIcon}
          </span>
          <span className="absolute inset-0 flex items-center justify-center">
            <Spinner size="sm" />
            <span className="sr-only">{loadingLabel}</span>
          </span>
        </>
      ) : (
        <>
          {leadingIcon}
          {children}
          {trailingIcon}
        </>
      )}
    </button>
  )
}

export interface ButtonLinkProps {
  href: string
  variant?: ButtonVariant
  size?: ButtonSize
  block?: boolean
  className?: string
  children?: ReactNode
  leadingIcon?: ReactNode
  trailingIcon?: ReactNode
  'aria-label'?: string
  'aria-current'?: 'page' | 'step' | 'true' | undefined
  target?: string
  rel?: string
  prefetch?: boolean
}

/** Anchor styled as a button, for when the action is really navigation. */
export function ButtonLink({
  href,
  variant = 'primary',
  size = 'md',
  block = false,
  className,
  children,
  leadingIcon,
  trailingIcon,
  ...props
}: ButtonLinkProps) {
  return (
    <Link href={href} className={buttonVariants({ variant, size, block, className })} {...props}>
      {leadingIcon}
      {children}
      {trailingIcon}
    </Link>
  )
}

export { buttonVariants }