@eifi1/ui-kit 0.17.0 → 0.18.0

package/src/components/progress-bar.tsx

@@ -2,6 +2,8 @@ import { useId } from "react";
 import type { ComponentPropsWithoutRef, ReactNode } from "react";
 import { cn } from "../lib/cn";
 import { DEFAULT_COMMON_LABELS, useKitLabels, useKitLocale } from "../i18n/kit-labels";
+import { toneTextClass } from "./signed-amount";
+import type { TextTone } from "./signed-amount";
 
 /** The words a progress bar adds of its own. */
 export interface ProgressBarLabels {
@@ -169,6 +171,18 @@ export interface ProgressBarProps extends Omit<ComponentPropsWithoutRef<"div">,
    * `legendValue={(seg, share) => <>{share} <Amount … /></>}`.
    */
   legendValue?: (segment: ProgressBarSegment, formatted: string, index: number) => ReactNode;
+  /**
+   * The colour of each legend row's figure, as a {@link TextTone} — `toneTextClass`'s
+   * palette, the money pair included. Default `"muted"`: the legend explains the bar and
+   * should not outshout the headline above it. One tone for every row, or a function
+   * per row. A tone and not the segment's own `tone`: keksdose's tax card fills its
+   * three parts with one bucket's certainty ramp (`className`), while the FIGURES carry
+   * the bucket's money direction — `legendTone="expense"` for the tax owed — which it
+   * could only say before through `legendValue` and an app-side `Amount`. A function
+   * returning `undefined` keeps that row muted. Applies to `legendValue`'s node too
+   * (it inherits the colour unless it sets its own).
+   */
+  legendTone?: TextTone | ((segment: ProgressBarSegment, index: number) => TextTone | undefined);
   /** A muted line under the bar — the plan's reset date, "3 of 5 seats in use". It
    *  describes the bar (`aria-describedby`). */
   hint?: ReactNode;
@@ -224,6 +238,7 @@ export function ProgressBar({
   segments,
   legend = false,
   legendValue,
+  legendTone = "muted",
   hint,
   overage,
   sensitive = false,
@@ -441,7 +456,12 @@ export function ProgressBar({
               <span
                 data-part="legend-value"
                 data-private={priv}
-                className="ms-auto shrink-0 text-xs tabular-nums text-[var(--text-muted)]"
+                className={cn(
+                  "ms-auto shrink-0 text-xs tabular-nums",
+                  toneTextClass(
+                    (typeof legendTone === "function" ? legendTone(seg, i) : legendTone) ?? "muted",
+                  ),
+                )}
               >
                 {legendValue ? legendValue(seg, formatPart(seg.value), i) : formatPart(seg.value)}
               </span>

package/src/components/reauth-dialog.tsx

@@ -0,0 +1,273 @@
+import { useContext, useEffect, useId, useRef, useState } from "react";
+import type { KeyboardEvent, ReactNode } from "react";
+
+import { useKitLabels } from "../i18n/kit-labels";
+import { usePromisePending } from "./danger-confirm";
+import { DialogFrame } from "./dialog-frame";
+import { ModalCloseContext } from "./modal";
+import { Button, Input, Spinner } from "./ui";
+
+/**
+ * Every string the dialog renders — the `reauthDialog` namespace of
+ * `<UiKitProvider labels>`, and overridable per instance through `labels`. The title,
+ * description and submit button are usually worded per action ("Add a passkey"),
+ * which is what the `title` / `description` / `submitLabel` props are for; these are
+ * the fallbacks.
+ */
+export interface ReauthDialogLabels {
+  title: string;
+  description: string;
+  /** Label of the password field. */
+  password: string;
+  submit: string;
+  cancel: string;
+}
+
+export const DEFAULT_REAUTH_DIALOG_LABELS: ReauthDialogLabels = {
+  title: "Confirm it’s you",
+  description: "Enter your current password to continue.",
+  password: "Current password",
+  submit: "Continue",
+  cancel: "Cancel",
+};
+
+export interface ReauthDialogProps {
+  /**
+   * Verifies the password — the app's call, e.g. the request the password guards.
+   *
+   * Return a promise and the dialog manages itself: busy until it settles, closes
+   * (`onClose(true)`) when it resolves, STAYS OPEN with the password kept and selected
+   * when it rejects — a wrong password is a typo to correct, not a sign-out. Pass the
+   * reason as `error`. Return nothing and the app owns the rest: `busy` for the
+   * pending state, unmounting the dialog once it is done.
+   */
+  onSubmit: (password: string) => void | Promise<unknown>;
+  /**
+   * The dialog has closed: `true` after a resolved `onSubmit`, `false` for Cancel,
+   * Escape, the backdrop and Back. A dismissal while `onSubmit` is still running also
+   * answers `false`, and that call's late result is then ignored.
+   */
+  onClose: (confirmed: boolean) => void;
+  /**
+   * Why the last attempt failed ("Wrong password"), shown under the field, which turns
+   * invalid (`aria-invalid`, `--danger-border-strong`). The app decides the wording —
+   * a 400 is a wrong password, a 500 is not. Hidden again as soon as the user edits
+   * the field (the message is about the password they had typed), and shown again by
+   * the next failed submit.
+   */
+  error?: ReactNode;
+  /** The check is running, for a caller that tracks it itself (a mutation's
+   *  `isPending`); a promise returned from `onSubmit` does the same on its own. */
+  busy?: boolean;
+  /** Default: `labels.title` — "Confirm it’s you". */
+  title?: ReactNode;
+  /** The line under the title. Default: `labels.description`. */
+  description?: ReactNode;
+  /** Text of the submit button. Default: `labels.submit` — "Continue". */
+  submitLabel?: ReactNode;
+  /** `"danger"` when what the password unlocks cannot be undone: the submit is then the
+   *  destructive button. Default `"neutral"`. */
+  tone?: "neutral" | "danger";
+  /** Extra body above the field — what is about to happen, a warning. */
+  children?: ReactNode;
+  /** Kept-mounted mode, as on `Modal`: left out, the dialog is open while mounted. A
+   *  flip to `false` animates it out and wipes the password. */
+  open?: boolean;
+  /** User-facing strings; see {@link ReauthDialogLabels}. */
+  labels?: Partial<ReauthDialogLabels>;
+}
+
+/**
+ * "Enter your current password to continue" — the step-up check in front of an
+ * action that changes how an account signs in (adding a passkey) or what it can
+ * reach. Kurvenschmiede asked for the password before registering a passkey in a
+ * dialog of its own; keksdose asks for it inline in `DangerConfirm`'s
+ * `requirePassword` tile. Both are the same three facts — the field is the CURRENT
+ * password (the password manager fills it, never generates one), a wrong one stays in
+ * the dialog with its error, and the APP verifies it — so the promise handling is
+ * `DangerConfirm`'s own, shared, the field is its `CurrentPasswordInput` spelled out
+ * with an `error`, and this is the modal form of them.
+ *
+ * A component rather than a `useReauth()` promise: the step that follows the check
+ * (Kurvenschmiede's WebAuthn ceremony) needs what the server answered, and the error
+ * wording needs the app's own status codes — both already live in the app's mutation,
+ * which this dialog only has to be handed (`onSubmit={(pw) => begin.mutateAsync(pw)}`,
+ * `error={…}`).
+ *
+ * The field is a `<form>`, so Enter submits once something is typed. Focus starts in
+ * the field and returns to the trigger through `Modal`'s trap. While a check runs,
+ * the field is read-only, Cancel is disabled and Escape is held: a request that has
+ * left cannot be cancelled by closing the dialog, and the dialog should not pretend it
+ * can.
+ */
+export function ReauthDialog({
+  onSubmit,
+  onClose,
+  error,
+  busy: busyProp,
+  title,
+  description,
+  submitLabel,
+  tone = "neutral",
+  children,
+  open,
+  labels: labelsProp,
+}: ReauthDialogProps) {
+  const labels = useKitLabels("reauthDialog", DEFAULT_REAUTH_DIALOG_LABELS, labelsProp);
+  const [password, setPassword] = useState("");
+  // The error describes the password that was submitted; once the user edits it, it
+  // describes nothing on screen. Cleared by the next submit, so a second failure with
+  // the same message shows again.
+  const [edited, setEdited] = useState(false);
+  const { pending, run } = usePromisePending();
+  const busy = Boolean(busyProp) || pending;
+  const inputRef = useRef<HTMLInputElement>(null);
+  // `onSubmit` resolved: the actions row lowers the panel (state, so it re-renders),
+  // and `onClose` answers true (a ref, because `Modal` may call the `onClose` it saw
+  // BEFORE that re-render — its latest-callback ref is refreshed in an effect that runs
+  // after the actions row's).
+  const [done, setDone] = useState(false);
+  const confirmed = useRef(false);
+  const formId = useId();
+  const isOpen = open ?? true;
+
+  // A close (kept-mounted) wipes the password: it must not sit in a hidden dialog.
+  // During render, like DangerConfirm's disarm, so no frame holds it.
+  const [wasOpen, setWasOpen] = useState(isOpen);
+  if (wasOpen !== isOpen) {
+    setWasOpen(isOpen);
+    if (!isOpen) {
+      setPassword("");
+      setEdited(false);
+      setDone(false);
+    }
+  }
+
+  // After `Modal`'s own effect (a parent's effects run after its children's), so the
+  // trap has recorded the trigger as its restore target before focus moves in.
+  useEffect(() => {
+    if (!isOpen) return;
+    confirmed.current = false;
+    inputRef.current?.focus();
+  }, [isOpen]);
+
+  const submit = () => {
+    if (busy || password === "") return;
+    setEdited(false);
+    run(onSubmit(password), () => {
+      confirmed.current = true;
+      setDone(true);
+    });
+  };
+
+  // A rejection leaves focus where it was (the field, or the submit button) — select
+  // the password there so the retry replaces it rather than appending to it.
+  const wasPending = useRef(false);
+  useEffect(() => {
+    if (wasPending.current && !pending && !done) inputRef.current?.select();
+    wasPending.current = pending;
+  }, [pending, done]);
+
+  const shownError = edited ? undefined : error;
+
+  return (
+    <DialogFrame
+      open={open}
+      title={title ?? labels.title}
+      description={description ?? labels.description}
+      onClose={() => onClose(confirmed.current)}
+      onKeyDown={(e: KeyboardEvent<HTMLDivElement>) => {
+        if (busy && e.key === "Escape") e.preventDefault();
+      }}
+      aria-busy={busy || undefined}
+      actions={
+        <ReauthActions
+          formId={formId}
+          done={done}
+          busy={busy}
+          canSubmit={password !== ""}
+          danger={tone === "danger"}
+          cancelLabel={labels.cancel}
+          submitLabel={submitLabel ?? labels.submit}
+        />
+      }
+    >
+      {children}
+      <form
+        id={formId}
+        noValidate
+        onSubmit={(e) => {
+          e.preventDefault();
+          submit();
+        }}
+      >
+        {/* CurrentPasswordInput's field — the password manager fills it with the CURRENT
+            password and never offers to generate one; `readOnly`, not `disabled`, while
+            busy, because disabling the field that has focus drops focus to <body> —
+            plus `Input`'s own `error`, which that helper does not take. The message
+            paints the field, sits under it and is its `aria-describedby`; passing the
+            prop on every render keeps the field's box steady, so the message going away
+            on the first keystroke of a retry no longer remounts the <input> under the
+            typist (it did, which is why this used to draw its own message). */}
+        <Input
+          ref={inputRef}
+          type="password"
+          autoComplete="current-password"
+          label={labels.password}
+          value={password}
+          readOnly={busy}
+          error={shownError}
+          onChange={(e) => {
+            setPassword(e.target.value);
+            setEdited(true);
+          }}
+        />
+      </form>
+    </DialogFrame>
+  );
+}
+
+/**
+ * The actions row. A component of its own because it renders INSIDE the `Modal`, where
+ * the panel's animated close is in context: a resolved `onSubmit` lowers the panel
+ * through it, the way Cancel and Escape do, and `Modal` then calls `onClose`.
+ */
+function ReauthActions({
+  formId,
+  done,
+  busy,
+  canSubmit,
+  danger,
+  cancelLabel,
+  submitLabel,
+}: {
+  formId: string;
+  done: boolean;
+  busy: boolean;
+  canSubmit: boolean;
+  danger: boolean;
+  cancelLabel: ReactNode;
+  submitLabel: ReactNode;
+}) {
+  const close = useContext(ModalCloseContext);
+  useEffect(() => {
+    if (done) close?.();
+  }, [done, close]);
+  return (
+    <>
+      <Button type="button" variant="ghost" disabled={busy} onClick={() => close?.()}>
+        {cancelLabel}
+      </Button>
+      <Button
+        type="submit"
+        form={formId}
+        variant={danger ? "danger" : "primary"}
+        disabled={!canSubmit || busy}
+        aria-busy={busy || undefined}
+      >
+        {busy && <Spinner label={null} className="h-4 w-4" />}
+        {submitLabel}
+      </Button>
+    </>
+  );
+}

package/src/components/server-wake.tsx

@@ -0,0 +1,124 @@
+import { useSyncExternalStore } from "react";
+import type { CSSProperties } from "react";
+
+import { useKitLabels } from "../i18n/kit-labels";
+import { cn } from "../lib/cn";
+import { serverWake } from "../lib/server-wake";
+import type { ServerWakeStage, ServerWakeWatcher } from "../lib/server-wake";
+import { AlertBanner } from "./alert-banner";
+import { Spinner } from "./ui";
+
+/**
+ * The visible half of the cold-start watchdog (`lib/server-wake.ts`), keksdose's
+ * `app/server-wake-notice.tsx` lifted into the kit: after a couple of seconds of an
+ * unanswered read it says the app is still loading, and after seven it says WHY — the
+ * server sleeps when nobody is using it, and the first request has to start it again.
+ *
+ * Corner-anchored and non-blocking on purpose. The pages underneath already show their
+ * own skeletons; what was missing is the explanation, not another overlay. Start
+ * corner, above the phone's bottom nav, so it collides with neither the centred toasts
+ * nor the nav bar.
+ *
+ * Mount it next to the router, not inside the app layout, so it also covers the login
+ * screen and the landing page — a cold start is at its most confusing exactly there,
+ * before anything of the app is on screen.
+ */
+
+// ── Labels ────────────────────────────────────────────────────────────────────
+
+export interface ServerWakeLabels {
+  /** Past `slowMs` (2 s): a warm server would have answered by now. */
+  slow: string;
+  /** Past `wakingMs` (7 s): the explanation. `appName` is the notice's prop; without
+   *  one the sentence says "the app". */
+  waking: (appName?: string) => string;
+}
+
+export const DEFAULT_SERVER_WAKE_LABELS: ServerWakeLabels = {
+  slow: "Still loading — this is taking longer than usual.",
+  waking: (appName) =>
+    `The server goes to sleep when nobody is using ${appName ?? "the app"}, so the first request after a break has to start it again. That can take a moment — nothing is lost, the page fills in by itself.`,
+};
+
+// ── Hook ──────────────────────────────────────────────────────────────────────
+
+/** The watcher's current stage, re-rendering on every change. Default: the shared
+ *  {@link serverWake} instance. */
+export function useServerWakeStage(watcher: ServerWakeWatcher = serverWake): ServerWakeStage {
+  // The server snapshot is `idle`: nothing is in flight while the HTML is rendered.
+  return useSyncExternalStore(watcher.subscribe, watcher.getStage, () => "idle");
+}
+
+// ── Notice ────────────────────────────────────────────────────────────────────
+
+export interface ServerWakeNoticeProps {
+  /** Default: the shared {@link serverWake} instance. Pass the app's own when it was
+   *  made with {@link createServerWake} (e.g. to watch the login POST too). */
+  watcher?: ServerWakeWatcher;
+  /** Named in the `waking` sentence ("…when nobody is using Keksdose…"). Default: the
+   *  label says "the app". */
+  appName?: string;
+  labels?: Partial<ServerWakeLabels>;
+  /**
+   * The height to keep clear at the bottom — AppShell's bottom nav. Default: its
+   * measured `--app-nav-h` (0px from `md` up and on pages without a shell, such as the
+   * login screen), so nothing has to be passed under an AppShell. The safe area is
+   * respected either way, and a 1rem gap is added. Numbers are px.
+   */
+  navOffset?: string | number;
+  /** Extra classes on the fixed anchor — a different width or `start-*`. The bottom
+   *  offset is an inline style, so move it vertically with {@link navOffset}. */
+  className?: string;
+}
+
+const px = (v: string | number) => (typeof v === "number" ? `${v}px` : v);
+
+/**
+ * Renders nothing visible while idle. The LIVE REGION, though, is always mounted: a
+ * `role="status"` element inserted together with its text is announced unreliably
+ * (several screen readers only speak changes to a region they already knew about),
+ * so the region waits empty and the banner appears inside it. keksdose's notice
+ * mounted the region and the words at once.
+ */
+export function ServerWakeNotice({ watcher, appName, labels: labelsProp, navOffset, className }: ServerWakeNoticeProps) {
+  const labels = useKitLabels("serverWake", DEFAULT_SERVER_WAKE_LABELS, labelsProp);
+  const stage = useServerWakeStage(watcher);
+  const waking = stage === "waking";
+  const style: CSSProperties = {
+    bottom: `calc(max(${navOffset === undefined ? "var(--app-nav-h, 0px)" : px(navOffset)}, env(safe-area-inset-bottom, 0px)) + 1rem)`,
+  };
+
+  return (
+    <div
+      role="status"
+      aria-live="polite"
+      data-stage={stage}
+      style={style}
+      // `pointer-events-none` on the empty anchor: a fixed box, even an empty one, is not
+      // allowed to swallow a tap on what it sits over.
+      className={cn(
+        "fixed start-4 z-50 max-w-[min(24rem,calc(100vw-2rem))]",
+        stage === "idle" && "pointer-events-none",
+        className,
+      )}
+    >
+      {stage !== "idle" && (
+        // `elevated`: OPAQUE in both themes (keksdose live #209) — the notice that
+        // explains a stall is read over whatever stalled, and a translucent dark tint
+        // let the page's own text show through it. A box banner is role-less, so the
+        // wrapper above stays the one live region.
+        <AlertBanner
+          tone={waking ? "warning" : "neutral"}
+          size="sm"
+          elevated
+          // `label={null}`: a Spinner is its own `role="status"` saying "Loading…" —
+          // nested here, a second live region and a second announcement ahead of the
+          // words that actually explain the wait. Here it is decoration.
+          icon={<Spinner label={null} className="h-3.5 w-3.5" />}
+        >
+          {waking ? labels.waking(appName) : labels.slow}
+        </AlertBanner>
+      )}
+    </div>
+  );
+}