@shoppexio/storefront-react 0.3.0 → 0.5.0

package/eject/account/subscriptions.tsx

@@ -9,10 +9,16 @@
  *
  * The payment-method portal is NOT one of them. That route answers with a
  * signed redirect into the provider's own portal, and any script sharing this
- * origin could fetch the link and forward it, so the lane renders no control
- * for it whatsoever — not a disabled one, which would promise that pressing it
- * would work. The buyer reaches the portal from the store's own emails, and the
- * panel says so rather than pretending the capability does not exist.
+ * origin could fetch the link and forward it. So "Update card" is a link to the
+ * hosted billing page on the checkout host (design Batch 7, 5b), which asks for
+ * its own email code before it mints the portal session; the producer's
+ * `can_manage_payment_method` decides whether it shows.
+ *
+ * Pausing asks first (Design Batch 4, feature 6): a small card with the lengths
+ * and resume dates the producer offers in `pause_options`, a reason only when
+ * the shop asks for one, and "Pause until {date}". A running or scheduled pause
+ * and the yearly limit are read from `pause` and `pause_limit`; "Don't pause"
+ * calls off a scheduled pause through the resume route.
  *
  * List and detail are two views of one panel. The platform defines a detail
  * path for orders and for nothing else, so a `/dashboard/subscriptions/<id>`
@@ -22,17 +28,35 @@
 
 import { useState, type ReactNode } from 'react';
 import { Link } from 'react-router-dom';
+import { accountOrderHref } from '@shoppexio/storefront-react';
 import {
+  billingEntryDays,
+  billingEntryTitle,
   billingMessage,
   cancelsAtPeriodEnd,
+  defaultPauseLength,
+  endedAfterHold,
+  endedNoteKey,
   narrowBillingHistory,
+  noteIntervalKey,
+  openRenewalState,
+  pausesLeftMessage,
+  renewalDate,
+  resumeBillsToday,
+  type OpenRenewalState,
   subscriptionTiming,
   subscriptionTimingKey,
 } from './account-subscriptions';
-import { callCustomerApi } from './customer-account';
-import type { SdkCustomerSubscription } from '@shoppexio/storefront-react';
+import { callCustomerApi, safeExternalHref } from './customer-account';
+import { hostedPageHref } from './hosted-page';
+import type {
+  SdkCustomerOpenRenewal,
+  SdkCustomerPauseOptions,
+  SdkCustomerPauseReason,
+  SdkCustomerSubscription,
+} from '@shoppexio/storefront-react';
 import { t } from './i18n';
-import { LockIcon } from './icons';
+import { CircleAlertIcon } from './icons';
 import { useAccountDashboard } from './dashboard';
 import {
   AccountBackButton,
@@ -43,6 +67,8 @@ import {
   AccountRowsSkeleton,
   AccountSectionTitle,
   BusySpinner,
+  HostedPageLink,
+  InvoiceStatusChip,
   StatusChip,
   formatAccountAmount,
   formatAccountDate,
@@ -125,8 +151,9 @@ export function AccountSubscriptions() {
                 {formatAccountAmount(subscription.plan.price, subscription.plan.currency)}
               </span>
             ) : null}
-            <StatusChip status={subscription.status} />
+            <SubscriptionStatus subscription={subscription} />
           </button>
+          <RenewalDue subscription={subscription} className="sxa:mt-2" />
         </li>
       ))}
     </ul>
@@ -157,14 +184,19 @@ function SubscriptionDetail({
   onBack: () => void;
   onChanged: (message: string) => void;
 }) {
-  const [pendingAction, setPendingAction] = useState<'pause' | 'resume' | 'cancel' | null>(null);
+  const [pendingAction, setPendingAction] = useState<'pause' | 'resume' | 'unpause' | 'cancel' | null>(null);
   const [confirmingCancel, setConfirmingCancel] = useState(false);
+  const [pausing, setPausing] = useState(false);
   const [actionError, setActionError] = useState<string | null>(null);
 
   const atPeriodEnd = cancelsAtPeriodEnd(subscription.gateway);
+  // Pause opens the dialog, so it needs the lengths the producer offers; an SDK
+  // older than the pause policy strips them, and then nothing is offered.
+  const pauseOptions = subscription.actions.can_pause ? subscription.pause_options ?? null : null;
+  const scheduledPause = subscription.pause?.state === 'scheduled';
 
   const run = async (
-    action: 'pause' | 'resume' | 'cancel',
+    action: 'resume' | 'unpause' | 'cancel',
     call: () => Promise<{ success: boolean; message?: string }>,
     doneMessage: string,
   ) => {
@@ -197,12 +229,19 @@ function SubscriptionDetail({
             {t('subscriptions.startedOn', { date: formatAccountDate(subscription.created_at) })}
           </p>
         </div>
-        <StatusChip status={subscription.status} />
+        <SubscriptionStatus subscription={subscription} />
       </div>
 
       {notice ? <AccountNotice message={notice} /> : null}
       {actionError ? <div className="sxa:mt-3"><AccountError message={actionError} /></div> : null}
 
+      <RenewalDue subscription={subscription} className="sxa:mt-3" />
+      <PauseState subscription={subscription} />
+
+      {subscription.status === 'PAST_DUE' && subscription.actions.can_manage_payment_method ? (
+        <PastDueCard subscription={subscription} />
+      ) : null}
+
       <AccountCard className="sxa:mt-5 sxa:p-6">
         {subscription.plan ? (
           <>
@@ -232,17 +271,13 @@ function SubscriptionDetail({
         </dl>
       </AccountCard>
 
-      {/*
-        Where a "Manage payment method" button would have gone. The flag is true
-        for every Stripe plan, cancelled ones included, and the route behind it
-        answers with a signed provider URL — so this lane renders the sentence
-        and no control at all.
-      */}
       {subscription.actions.can_manage_payment_method ? (
-        <p className="sxa:mt-4 sxa:flex sxa:items-start sxa:gap-2 sxa:text-small sxa:text-muted">
-          <LockIcon className="sxa:mt-0.5 sxa:h-4 sxa:w-4 sxa:shrink-0" />
-          {t('subscriptions.paymentMethodElsewhere')}
-        </p>
+        <HostedPageLink
+          page="billing"
+          hints={{ subscription: subscription.uniqid }}
+          label={t('subscriptions.updateCard')}
+          className="sxa:mt-4"
+        />
       ) : null}
 
       {/*
@@ -251,37 +286,36 @@ function SubscriptionDetail({
         control still promises that pressing it would have worked.
       */}
       <div className="sxa:mt-6 sxa:flex sxa:flex-wrap sxa:gap-2">
-        {subscription.actions.can_pause ? (
+        {pauseOptions && !pausing ? (
           <button
             type="button"
             disabled={pendingAction !== null}
-            aria-busy={pendingAction === 'pause' || undefined}
             className="sx-account-button sxa:card-button sxa:card-button--add sxa:disabled:cursor-not-allowed sxa:disabled:opacity-50"
-            onClick={() => void run(
-              'pause',
-              () => callCustomerApi((sdk) => sdk.pauseSubscription(subscription.uniqid)),
-              t('subscriptions.paused'),
-            )}
+            onClick={() => {
+              setConfirmingCancel(false);
+              setActionError(null);
+              setPausing(true);
+            }}
           >
-            {pendingAction === 'pause' ? <BusySpinner className="sxa:mr-1.5 sxa:h-3.5 sxa:w-3.5" /> : null}
-            {pendingAction === 'pause' ? t('subscriptions.pausing') : t('subscriptions.pause')}
+            {t('subscriptions.pause')}
           </button>
         ) : null}
 
+        {/* `can_resume` is "Resume now" on a paused plan and "Don't pause" on a scheduled pause. */}
         {subscription.actions.can_resume ? (
           <button
             type="button"
             disabled={pendingAction !== null}
-            aria-busy={pendingAction === 'resume' || undefined}
+            aria-busy={pendingAction === 'resume' || pendingAction === 'unpause' || undefined}
             className="sx-account-button sxa:card-button sxa:card-button--add sxa:disabled:cursor-not-allowed sxa:disabled:opacity-50"
             onClick={() => void run(
-              'resume',
+              scheduledPause ? 'unpause' : 'resume',
               () => callCustomerApi((sdk) => sdk.resumeSubscription(subscription.uniqid)),
-              t('subscriptions.resumed'),
+              scheduledPause ? t('subscriptions.pauseCalledOff') : t('subscriptions.resumed'),
             )}
           >
-            {pendingAction === 'resume' ? <BusySpinner className="sxa:mr-1.5 sxa:h-3.5 sxa:w-3.5" /> : null}
-            {pendingAction === 'resume' ? t('subscriptions.resuming') : t('subscriptions.resume')}
+            {pendingAction === 'resume' || pendingAction === 'unpause' ? <BusySpinner className="sxa:mr-1.5 sxa:h-3.5 sxa:w-3.5" /> : null}
+            {pendingAction === 'resume' ? t('subscriptions.resuming') : scheduledPause ? t('subscriptions.dontPause') : t('subscriptions.resumeNow')}
           </button>
         ) : null}
 
@@ -290,13 +324,42 @@ function SubscriptionDetail({
             type="button"
             disabled={pendingAction !== null}
             className="sx-account-button sxa:card-button sxa:card-button--add sxa:disabled:cursor-not-allowed sxa:disabled:opacity-50"
-            onClick={() => setConfirmingCancel(true)}
+            onClick={() => {
+              setPausing(false);
+              setConfirmingCancel(true);
+            }}
           >
             {t('subscriptions.cancel')}
           </button>
         ) : null}
       </div>
 
+      {subscription.pause_limit ? (
+        <p className="sxa:mt-3 sxa:text-small sxa:text-muted">
+          {subscription.pause_limit.pauses_per_year === 1
+            ? t('subscriptions.pauseLimitOne', { date: formatAccountDate(subscription.pause_limit.available_again_at) })
+            : t('subscriptions.pauseLimit', {
+              count: subscription.pause_limit.pauses_per_year,
+              date: formatAccountDate(subscription.pause_limit.available_again_at),
+            })}
+        </p>
+      ) : null}
+
+      {pausing && pauseOptions ? (
+        <PauseDialog
+          key={subscription.uniqid}
+          subscription={subscription}
+          options={pauseOptions}
+          busy={pendingAction !== null}
+          onBusy={(busy) => setPendingAction(busy ? 'pause' : null)}
+          onClose={() => setPausing(false)}
+          onPaused={() => {
+            setPausing(false);
+            onChanged(t('subscriptions.pauseSavedNotice'));
+          }}
+        />
+      ) : null}
+
       {/*
         Cancelling asks first, and the question names what cancelling does on
         THIS gateway. PayPal cannot stop a billing agreement at the period
@@ -347,6 +410,268 @@ function SubscriptionDetail({
   );
 }
 
+/**
+ * An open renewal, and the way to pay it: on hold, due, or invoiced ahead.
+ * The producer names the invoice's hosted checkout in `open_renewal`, so this
+ * is a plain link, never a call: paying is a purchase, and purchases carry
+ * their authorisation in checkout (ADR-0064). Nothing open (or a backend that
+ * does not send the field yet), nothing shown. A URL that fails the scheme check
+ * gets no anchor, only the sentence, because the payment is still due.
+ */
+function RenewalDue({ subscription, className }: { subscription: SdkCustomerSubscription; className: string }) {
+  const ended = endedAfterHold(subscription);
+  if (ended) {
+    return (
+      <AccountCard className={`${className} sxa:px-5 sxa:py-3`}>
+        <p className="sxa:text-small">{t(endedNoteKey(ended))}</p>
+      </AccountCard>
+    );
+  }
+  const state = openRenewalState(subscription);
+  const open = subscription.open_renewal;
+  if (state === null || !open) return null;
+  const href = safeExternalHref(open.pay_url);
+  const { note, payLabel } = renewalCopy(subscription, state, open);
+
+  return (
+    <AccountCard className={`${className} sxa:flex sxa:flex-wrap sxa:items-center sxa:justify-between sxa:gap-3 sxa:px-5 sxa:py-3`}>
+      <p className="sxa:min-w-0 sxa:text-small">{note}</p>
+      {href === null ? null : (
+        <a
+          href={href}
+          className="sx-account-cta sxa:cta-button sxa:inline-flex sxa:h-9 sxa:shrink-0 sxa:items-center sxa:px-4 sxa:text-small sxa:font-semibold"
+        >
+          {payLabel}
+        </a>
+      )}
+    </AccountCard>
+  );
+}
+
+const PAUSE_LENGTH_KEYS: Readonly<Record<SdkCustomerPauseOptions['lengths'][number]['days'], string>> = {
+  7: 'subscriptions.pauseLength7',
+  14: 'subscriptions.pauseLength14',
+  30: 'subscriptions.pauseLength30',
+  60: 'subscriptions.pauseLength60',
+  90: 'subscriptions.pauseLength90',
+};
+
+/** `SUBSCRIPTION_PAUSE_REASONS`, in the producer's order, with their buyer labels. */
+const PAUSE_REASONS: ReadonlyArray<readonly [SdkCustomerPauseReason, string]> = [
+  ['taking_a_break', 'subscriptions.pauseReasonTakingABreak'],
+  ['too_expensive', 'subscriptions.pauseReasonTooExpensive'],
+  ['not_using', 'subscriptions.pauseReasonNotUsing'],
+  ['not_working', 'subscriptions.pauseReasonNotWorking'],
+  ['other', 'subscriptions.pauseReasonOther'],
+];
+
+/**
+ * The pause dialog: the lengths the producer offers, each with its resume date, a reason
+ * when the shop asks for one, and what the pause means. A failure keeps the dialog and
+ * says nothing changed; the buyer tries again from here.
+ */
+function PauseDialog({
+  subscription,
+  options,
+  busy,
+  onBusy,
+  onClose,
+  onPaused,
+}: {
+  subscription: SdkCustomerSubscription;
+  options: SdkCustomerPauseOptions;
+  busy: boolean;
+  onBusy: (busy: boolean) => void;
+  onClose: () => void;
+  onPaused: () => void;
+}) {
+  const [days, setDays] = useState(() => defaultPauseLength(options));
+  const [reason, setReason] = useState<SdkCustomerPauseReason | ''>('');
+  const [failed, setFailed] = useState(false);
+  const length = options.lengths.find((entry) => entry.days === days) ?? null;
+  const start = formatAccountDate(options.starts_at);
+  const startsLater = Date.parse(options.starts_at) > Date.now();
+  const left = pausesLeftMessage(options.pauses_left_after);
+
+  const confirm = async () => {
+    if (!length) return;
+    onBusy(true);
+    setFailed(false);
+    const result = await callCustomerApi((sdk) => sdk.pauseSubscription(subscription.uniqid, {
+      length_days: length.days,
+      ...(options.reason_enabled && reason !== '' ? { reason } : {}),
+    }));
+    onBusy(false);
+    if (!result.success) {
+      setFailed(true);
+      return;
+    }
+    onPaused();
+  };
+
+  return (
+    <AccountCard className="sxa:mt-4 sxa:p-6">
+      <p className="sxa:font-heading sxa:font-semibold">
+        {t('subscriptions.pauseTitle', { plan: subscription.plan?.name ?? t('subscriptions.unnamedPlan') })}
+      </p>
+      {startsLater ? (
+        <p className="sxa:mt-2 sxa:text-small sxa:text-muted">{t('subscriptions.pauseStartsAfter', { date: start })}</p>
+      ) : null}
+
+      <p className="sxa:mt-4 sxa:text-small sxa:font-semibold">{t('subscriptions.pauseHowLong')}</p>
+      <div className="sxa:mt-2 sxa:flex sxa:flex-wrap sxa:gap-2" role="radiogroup" aria-label={t('subscriptions.pauseHowLong')}>
+        {options.lengths.map((entry) => (
+          <button
+            key={entry.days}
+            type="button"
+            role="radio"
+            aria-checked={entry.days === days}
+            disabled={busy}
+            className={`sx-account-button sxa:card-button ${entry.days === days ? 'sxa:card-button--add' : ''} sxa:disabled:cursor-not-allowed sxa:disabled:opacity-50`}
+            onClick={() => setDays(entry.days)}
+          >
+            {t(PAUSE_LENGTH_KEYS[entry.days])}
+          </button>
+        ))}
+      </div>
+
+      {options.reason_enabled ? (
+        <label className="sxa:mt-4 sxa:block">
+          <span className="sxa:text-small sxa:font-semibold">{t('subscriptions.pauseReasonLabel')}</span>
+          <span className="sxa:text-small sxa:text-muted"> · {t('subscriptions.pauseOptional')}</span>
+          <select
+            value={reason}
+            disabled={busy}
+            onChange={(event) => setReason(PAUSE_REASONS.find(([value]) => value === event.target.value)?.[0] ?? '')}
+            className="sx-account-input sxa:mt-2 sxa:block sxa:w-full sxa:rounded-input sxa:border sxa:bg-surface sxa:px-3 sxa:py-2 sxa:text-small"
+          >
+            <option value="">{t('subscriptions.pauseReasonNone')}</option>
+            {PAUSE_REASONS.map(([value, key]) => <option key={value} value={value}>{t(key)}</option>)}
+          </select>
+        </label>
+      ) : null}
+
+      {length ? (
+        <ul className="sxa:mt-4 sxa:list-disc sxa:space-y-1 sxa:pl-5 sxa:text-small sxa:text-muted">
+          {[
+            t('subscriptions.pauseSummary', { start, end: formatAccountDate(length.resume_at) }),
+            pauseAccessLine(subscription),
+            t('subscriptions.pauseResumeAnyTime'),
+            t(left.key, left.params),
+          ].map((line) => <li key={line}>{line}</li>)}
+        </ul>
+      ) : null}
+
+      {failed ? <div className="sxa:mt-3"><AccountError message={t('subscriptions.pauseError')} /></div> : null}
+
+      <div className="sxa:mt-4 sxa:flex sxa:flex-wrap sxa:items-center sxa:gap-2">
+        {length ? (
+          <button
+            type="button"
+            disabled={busy}
+            aria-busy={busy || undefined}
+            className="sx-account-cta sxa:cta-button sxa:inline-flex sxa:h-8 sxa:items-center sxa:px-4 sxa:text-micro sxa:font-semibold sxa:disabled:cursor-not-allowed sxa:disabled:opacity-50"
+            onClick={() => void confirm()}
+          >
+            {busy ? <BusySpinner className="sxa:mr-1.5 sxa:h-3.5 sxa:w-3.5" /> : null}
+            {busy ? t('subscriptions.pausing') : t('subscriptions.pauseConfirm', { date: formatAccountDate(length.resume_at) })}
+          </button>
+        ) : null}
+        <button
+          type="button"
+          disabled={busy}
+          className="sx-account-button sxa:card-button sxa:card-button--add sxa:disabled:cursor-not-allowed sxa:disabled:opacity-50"
+          onClick={onClose}
+        >
+          {t('subscriptions.pauseKeep')}
+        </button>
+      </div>
+    </AccountCard>
+  );
+}
+
+/**
+ * A past-due Stripe plan: the last charge failed, and the card is what to
+ * change before the plan ends. The same hosted billing link as "Update card".
+ */
+function PastDueCard({ subscription }: { subscription: SdkCustomerSubscription }) {
+  // No shop or checkout host to link to: the notice would point at nothing.
+  if (hostedPageHref('billing', { subscription: subscription.uniqid }) === null) return null;
+  return (
+    <AccountCard className="sx-account-past-due sxa:mt-3 sxa:flex sxa:items-start sxa:gap-3 sxa:px-5 sxa:py-4">
+      <CircleAlertIcon className="sxa:mt-0.5 sxa:h-4 sxa:w-4 sxa:shrink-0 sxa:text-error" />
+      <div className="sxa:min-w-0 sxa:flex-1">
+        <p className="sxa:text-small sxa:font-semibold">{t('subscriptions.pastDueCardTitle')}</p>
+        <p className="sxa:mt-1 sxa:text-small sxa:text-muted">{t('subscriptions.pastDueCardBody')}</p>
+        <HostedPageLink
+          page="billing"
+          hints={{ subscription: subscription.uniqid }}
+          label={t('subscriptions.updateCard')}
+          hint={null}
+          className="sxa:mt-3"
+        />
+      </div>
+    </AccountCard>
+  );
+}
+
+/** What the pause takes: the Discord roles by name when the producer knows them, else "your access". */
+function pauseAccessLine(subscription: SdkCustomerSubscription): string {
+  const roles = subscription.pause_access_roles ?? [];
+  if (roles.length === 0) return t('subscriptions.pauseAccess');
+  return t(roles.length === 1 ? 'subscriptions.pauseAccessRole' : 'subscriptions.pauseAccessRoles', {
+    roles: roles.map((role) => `@${role}`).join(', '),
+  });
+}
+
+/** A running or scheduled pause, read from the producer's `pause`. */
+function PauseState({ subscription }: { subscription: SdkCustomerSubscription }) {
+  const pause = subscription.pause;
+  if (!pause || subscription.status.toUpperCase() === 'CANCELED') return null;
+  let title: string;
+  let body: string;
+  if (pause.state === 'scheduled') {
+    title = t('subscriptions.pauseScheduled', { date: formatAccountDate(pause.starts_at) });
+    body = pause.resume_at === null
+      ? t('subscriptions.pauseScheduledBodyOpenEnded')
+      : t('subscriptions.pauseScheduledBody', { date: formatAccountDate(pause.resume_at) });
+  } else {
+    title = pause.resume_at === null
+      ? t('subscriptions.pausedOpenEnded')
+      : t('subscriptions.pausedUntil', { date: formatAccountDate(pause.resume_at) });
+    const paused = `${t('subscriptions.pausedBody')} ${pauseAccessLine(subscription)}`;
+    body = subscription.plan && resumeBillsToday(subscription)
+      ? `${paused} ${t('subscriptions.pausedPayToday', {
+        price: formatAccountAmount(subscription.plan.price, subscription.plan.currency),
+      })}`
+      : paused;
+  }
+  return (
+    <AccountCard className="sxa:mt-3 sxa:px-5 sxa:py-3">
+      <p className="sxa:text-small sxa:font-semibold">{title}</p>
+      <p className="sxa:mt-0.5 sxa:text-small sxa:text-muted">{body}</p>
+    </AccountCard>
+  );
+}
+
+/** The subscription's status, or what its open renewal makes it: on hold, or payment due. */
+function SubscriptionStatus({ subscription }: { subscription: SdkCustomerSubscription }) {
+  const state = openRenewalState(subscription);
+  if (state === 'held') return <StatusChip status="PAST_DUE" label={t('subscriptions.statusOnHold')} />;
+  if (state === 'due') return <StatusChip status="PENDING" label={t('subscriptions.statusPaymentDue')} />;
+  return <StatusChip status={subscription.status} />;
+}
+
+/** The renewal note and the pay label for an open renewal. */
+function renewalCopy(subscription: SdkCustomerSubscription, state: OpenRenewalState, open: SdkCustomerOpenRenewal) {
+  const amount = formatAccountAmount(open.amount, open.currency);
+  const date = formatAccountDate(open.pay_by);
+  const renewal = formatAccountDate(renewalDate(subscription.current_period_end));
+  if (state === 'held') return { note: t('subscriptions.holdNote', { amount, date, interval: t(noteIntervalKey(open, 'hold')) }), payLabel: t('subscriptions.payAndResume', { amount }) };
+  const note = state === 'ready' ? t('subscriptions.readyNote', { renewal, interval: t(noteIntervalKey(open, 'ready')) }) : t('subscriptions.dueNote', { renewal, date });
+  return { note, payLabel: t('subscriptions.payAmount', { amount }) };
+}
+
 function DetailRow({ label, children }: { label: string; children: ReactNode }) {
   return (
     <div className="sxa:flex sxa:items-center sxa:justify-between sxa:gap-4">
@@ -380,7 +705,7 @@ function BillingHistory({ uniqid }: { uniqid: string }) {
   );
 }
 
-function BillingHistoryList({ payload, reload }: { payload: unknown; reload: () => void }) {
+export function BillingHistoryList({ payload, reload }: { payload: unknown; reload: () => void }) {
   const history = narrowBillingHistory(payload);
 
   /*
@@ -401,21 +726,33 @@ function BillingHistoryList({ payload, reload }: { payload: unknown; reload: ()
     );
   }
 
+  // Each row says what it billed and opens its order in the account, where the receipt is (Design Batch 9, C3).
   return (
     <ul className="sxa:space-y-4">
-      {history.invoices.map((invoice) => (
-        <li key={invoice.uniqid} className="sxa:flex sxa:items-center sxa:gap-4 sxa:rounded-input sxa:border sxa:bg-surface sxa:p-5 sxa:shadow-card">
-          <div className="sxa:min-w-0 sxa:flex-1">
-            <p className="sxa:truncate sxa:text-small sxa:font-semibold sxa:tabular-nums">
-              {formatAccountAmount(invoice.total, invoice.currency)}
-            </p>
-            <p className="sxa:mt-1 sxa:truncate sxa:text-micro sxa:text-muted">
-              {formatAccountDate(invoice.created_at)}
-            </p>
-          </div>
-          <StatusChip status={invoice.status} />
-        </li>
-      ))}
+      {history.invoices.map((invoice) => {
+        const title = billingEntryTitle(invoice);
+        const days = billingEntryDays(invoice);
+        return (
+          <li key={invoice.uniqid}>
+            <Link
+              to={accountOrderHref(invoice.uniqid)}
+              className="sxa:flex sxa:items-center sxa:gap-4 sxa:rounded-input sxa:border sxa:bg-surface sxa:p-5 sxa:shadow-card sxa:transition-opacity sxa:hover:opacity-80"
+            >
+              <div className="sxa:min-w-0 sxa:flex-1">
+                <p className="sxa:text-small sxa:font-semibold">{t(title.key, title.params)}</p>
+                <p className="sxa:mt-1 sxa:text-micro sxa:tabular-nums sxa:text-muted">
+                  {formatAccountDate(invoice.created_at)}
+                  {days ? ` · ${t(days.key, days.params)}` : null}
+                </p>
+              </div>
+              <div className="sxa:flex sxa:shrink-0 sxa:flex-col sxa:items-end sxa:gap-1.5 sxa:sm:flex-row sxa:sm:items-center sxa:sm:gap-3">
+                <span className="sxa:text-small sxa:font-semibold sxa:tabular-nums">{formatAccountAmount(invoice.total, invoice.currency)}</span>
+                <InvoiceStatusChip status={invoice.status} />
+              </div>
+            </Link>
+          </li>
+        );
+      })}
     </ul>
   );
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shoppexio/storefront-react",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "React hooks, models and a customer account for Shoppex code storefronts",
   "type": "module",
   "homepage": "https://docs.shoppex.io/storefront/code-storefront-development",
@@ -37,7 +37,7 @@
     "build": "tsup && bun run build:css && bun run build:eject",
     "build:css": "tailwindcss --input src/account/account.css --output dist/account.css --optimize",
     "lint": "biome lint src tests scripts",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsrs --noEmit",
     "test": "bun run build:css && bun test ./tests",
     "build:eject": "bun scripts/build-eject.ts"
   },
@@ -72,8 +72,8 @@
     "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
     "jsdom-cjs": "npm:jsdom@26.1.0",
-    "react": "19.2.7",
-    "react-dom": "19.2.7",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
     "react-router-dom": "7.18.1",
     "tailwindcss": "4.2.1",
     "tsup": "^8.5.0",