@alpic-ai/ui 0.0.0-dev.g2151e99 → 0.0.0-dev.g21c4835

package/src/components/heatmap-chart.tsx

@@ -0,0 +1,287 @@
+"use client";
+
+import * as React from "react";
+import { createPortal } from "react-dom";
+
+import type { ChartPaletteName } from "../lib/chart-palette";
+import { HEAT_EMPTY, heatColor, heatRamp } from "../lib/chart-palette";
+import { cn } from "../lib/cn";
+import { useChartContext } from "./chart-container";
+
+export interface HeatmapChartProps {
+  data: ReadonlyArray<Record<string, string | number | null | undefined>>;
+  xKey: string;
+  yKey: string;
+  dataKey?: string;
+  variant?: "square" | "dot";
+  palette?: ChartPaletteName;
+  xLabels?: readonly string[];
+  yLabels?: readonly string[];
+  highlightPeak?: boolean;
+  loading?: boolean;
+  valueFormatter?: (value: number) => string;
+  xTickFormatter?: (label: string) => string;
+  yTickFormatter?: (label: string) => string;
+  ariaLabel?: string;
+  className?: string;
+}
+
+interface HoverState {
+  x: number;
+  y: number;
+  rowLabel: string;
+  colLabel: string;
+  value: number;
+}
+
+const PLACEHOLDER_HEIGHT = 168;
+// viewBox units — the SVG scales to the container width, so these stay squares.
+const CELL = 22;
+const GAP = 3;
+const PAD = { left: 36, top: 18, right: 6, bottom: 6 };
+const MAX_X_TICKS = 13;
+// Dots never fully vanish at zero and never quite touch their neighbours at peak.
+const DOT_MIN = 0.42;
+const DOT_RANGE = 0.52;
+const TOOLTIP_OFFSET = 14;
+const TOOLTIP_WIDTH = 150;
+const TOOLTIP_HEIGHT = 64;
+
+// Unambiguous composite key — labels may themselves contain hyphens, spaces, etc.
+const pairKey = (rowLabel: string, colLabel: string) => JSON.stringify([rowLabel, colLabel]);
+
+const uniqueInOrder = (values: readonly string[]) => {
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+  for (const value of values) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      ordered.push(value);
+    }
+  }
+  return ordered;
+};
+
+function HeatmapChart({
+  data,
+  xKey,
+  yKey,
+  dataKey = "value",
+  variant = "square",
+  palette,
+  xLabels,
+  yLabels,
+  highlightPeak = true,
+  loading = false,
+  valueFormatter = (value) => value.toLocaleString("en-US"),
+  xTickFormatter,
+  yTickFormatter,
+  ariaLabel = "Activity heatmap",
+  className,
+}: HeatmapChartProps) {
+  const { paletteName, theme } = useChartContext(palette);
+  const [hovered, setHovered] = React.useState<HoverState | null>(null);
+  const [mounted, setMounted] = React.useState(false);
+
+  React.useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  const layout = React.useMemo(() => {
+    const columns = xLabels ? [...xLabels] : uniqueInOrder(data.map((row) => String(row[xKey] ?? "")));
+    const rows = yLabels ? [...yLabels] : uniqueInOrder(data.map((row) => String(row[yKey] ?? "")));
+    const valueAt = new Map<string, number>();
+    for (const row of data) {
+      valueAt.set(pairKey(String(row[yKey] ?? ""), String(row[xKey] ?? "")), Number(row[dataKey]) || 0);
+    }
+    let maxValue = 0;
+    let peakKey = "";
+    const cells = rows.flatMap((rowLabel, rowIndex) =>
+      columns.map((colLabel, colIndex) => {
+        const value = valueAt.get(pairKey(rowLabel, colLabel)) ?? 0;
+        if (value > maxValue) {
+          maxValue = value;
+          peakKey = pairKey(rowLabel, colLabel);
+        }
+        return { rowLabel, colLabel, rowIndex, colIndex, value };
+      }),
+    );
+    return { columns, rows, cells, maxValue, peakKey };
+  }, [data, xKey, yKey, dataKey, xLabels, yLabels]);
+
+  const { columns, rows, cells, maxValue, peakKey } = layout;
+  const isEmpty = columns.length === 0 || rows.length === 0 || maxValue <= 0;
+
+  if (loading) {
+    return (
+      <div
+        className={cn(
+          "flex items-center justify-center gap-2.5 font-mono text-quaternary-foreground text-text-xs",
+          className,
+        )}
+        style={{ minHeight: PLACEHOLDER_HEIGHT }}
+      >
+        <span className="size-4 animate-spin rounded-full border-2 border-border border-t-foreground" />
+        loading…
+      </div>
+    );
+  }
+
+  if (isEmpty) {
+    return (
+      <div
+        className={cn(
+          "flex items-center justify-center rounded-lg border border-border border-dashed font-mono text-quaternary-foreground text-text-xs",
+          className,
+        )}
+        style={{ minHeight: PLACEHOLDER_HEIGHT }}
+      >
+        no data in range
+      </div>
+    );
+  }
+
+  const ramp = heatRamp(paletteName, theme.isDark ? HEAT_EMPTY.dark : HEAT_EMPTY.light);
+  const totalWidth = PAD.left + columns.length * CELL + (columns.length - 1) * GAP + PAD.right;
+  const totalHeight = PAD.top + rows.length * CELL + (rows.length - 1) * GAP + PAD.bottom;
+  const xStride = Math.ceil(columns.length / MAX_X_TICKS);
+  const cellX = (col: number) => PAD.left + col * (CELL + GAP);
+  const cellY = (row: number) => PAD.top + row * (CELL + GAP);
+  const formatX = (label: string) => (xTickFormatter ? xTickFormatter(label) : label);
+  const formatY = (label: string) => (yTickFormatter ? yTickFormatter(label) : label);
+
+  // The tooltip follows the cursor; rendered through a portal so a transformed/
+  // clipped ancestor (e.g. the card's mount animation + overflow-hidden) can't
+  // shift or trim it. Flip near the viewport edges.
+  const tooltipLeft =
+    hovered && hovered.x + TOOLTIP_OFFSET + TOOLTIP_WIDTH > window.innerWidth
+      ? hovered.x - TOOLTIP_OFFSET - TOOLTIP_WIDTH
+      : (hovered?.x ?? 0) + TOOLTIP_OFFSET;
+  const tooltipTop =
+    hovered && hovered.y + TOOLTIP_OFFSET + TOOLTIP_HEIGHT > window.innerHeight
+      ? hovered.y - TOOLTIP_OFFSET - TOOLTIP_HEIGHT
+      : (hovered?.y ?? 0) + TOOLTIP_OFFSET;
+
+  return (
+    <div data-slot="heatmap-chart" className={cn("w-full", className)}>
+      <div className="overflow-x-auto">
+        <svg
+          viewBox={`0 0 ${totalWidth} ${totalHeight}`}
+          className="block min-w-[480px]"
+          style={{ width: "100%", height: "auto" }}
+          role="img"
+          aria-label={ariaLabel}
+          onMouseLeave={() => setHovered(null)}
+        >
+          {columns.map((label, col) =>
+            col % xStride === 0 ? (
+              <text
+                key={`x-${label}`}
+                x={cellX(col) + CELL / 2}
+                y={PAD.top - 7}
+                textAnchor="middle"
+                className="fill-quaternary-foreground font-mono text-[8.5px]"
+              >
+                {formatX(label)}
+              </text>
+            ) : null,
+          )}
+          {rows.map((label, row) => (
+            <text
+              key={`y-${label}`}
+              x={PAD.left - 8}
+              y={cellY(row) + CELL / 2 + 3}
+              textAnchor="end"
+              className="fill-quaternary-foreground font-mono text-[8.5px]"
+            >
+              {formatY(label)}
+            </text>
+          ))}
+          {cells.map((cell) => {
+            const fraction = cell.value / maxValue;
+            const fill = heatColor(ramp, fraction);
+            const key = pairKey(cell.rowLabel, cell.colLabel);
+            const isPeak = highlightPeak && key === peakKey;
+            if (variant === "dot") {
+              return (
+                <circle
+                  key={key}
+                  cx={cellX(cell.colIndex) + CELL / 2}
+                  cy={cellY(cell.rowIndex) + CELL / 2}
+                  r={(CELL / 2) * (DOT_MIN + DOT_RANGE * fraction)}
+                  fill={fill}
+                  stroke={isPeak ? theme.foreground : undefined}
+                  strokeWidth={isPeak ? 1.4 : undefined}
+                />
+              );
+            }
+            return (
+              <rect
+                key={key}
+                x={cellX(cell.colIndex)}
+                y={cellY(cell.rowIndex)}
+                width={CELL}
+                height={CELL}
+                rx={2.5}
+                fill={fill}
+                stroke={isPeak ? theme.foreground : undefined}
+                strokeWidth={isPeak ? 1.4 : undefined}
+              />
+            );
+          })}
+          {/* Transparent hit layer over the full pitch so every cell — and the gaps
+              between dots — registers hover uniformly. */}
+          {cells.map((cell) => (
+            // biome-ignore lint/a11y/noStaticElementInteractions: decorative hover tooltip; all values are visible on the cells
+            <rect
+              key={`hit-${pairKey(cell.rowLabel, cell.colLabel)}`}
+              x={cellX(cell.colIndex)}
+              y={cellY(cell.rowIndex)}
+              width={CELL + GAP}
+              height={CELL + GAP}
+              fill="transparent"
+              onMouseMove={(event) =>
+                setHovered({
+                  x: event.clientX,
+                  y: event.clientY,
+                  rowLabel: cell.rowLabel,
+                  colLabel: cell.colLabel,
+                  value: cell.value,
+                })
+              }
+            />
+          ))}
+        </svg>
+      </div>
+
+      {mounted &&
+        hovered &&
+        createPortal(
+          <div
+            className="pointer-events-none fixed z-50 min-w-[130px] rounded-lg border border-border bg-popover px-3 py-2.5 text-popover-foreground shadow-lg"
+            style={{ left: tooltipLeft, top: tooltipTop }}
+          >
+            <p className="mb-1.5 font-mono text-[10px] text-quaternary-foreground uppercase tracking-wider">
+              {formatY(hovered.rowLabel)} · {formatX(hovered.colLabel)}
+            </p>
+            <div className="flex items-center justify-between gap-4 text-text-xs">
+              <span className="inline-flex items-center gap-2 text-muted-foreground">
+                <span
+                  aria-hidden
+                  className="size-2 shrink-0 rounded-[2px]"
+                  style={{ background: heatColor(ramp, hovered.value / maxValue) }}
+                />
+                activity
+              </span>
+              <span className="font-mono font-semibold tabular-nums text-foreground">
+                {valueFormatter(hovered.value)}
+              </span>
+            </div>
+          </div>,
+          document.body,
+        )}
+    </div>
+  );
+}
+
+export { HeatmapChart };

package/src/components/line-chart.tsx

@@ -0,0 +1,264 @@
+"use client";
+
+import * as React from "react";
+import {
+  CartesianGrid,
+  LabelList,
+  Line,
+  LineChart as RechartsLineChart,
+  ReferenceArea,
+  ReferenceDot,
+  ReferenceLine,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from "recharts";
+
+import { useReducedMotion } from "../hooks/use-reduced-motion";
+import { type ChartSeries, resolveSeries } from "../lib/chart";
+import type { ChartPaletteName } from "../lib/chart-palette";
+import { cn } from "../lib/cn";
+import type { ChartMarker } from "./area-chart";
+import { useChartContext } from "./chart-container";
+import { ChartLegend } from "./chart-legend";
+import { ChartTooltipContent } from "./chart-tooltip";
+
+const CURVE_TYPE = { monotone: "monotone", linear: "linear", step: "stepAfter" } as const;
+
+export interface LineChartProps {
+  data: ReadonlyArray<Record<string, string | number | null | undefined>>;
+  index: string;
+  series: ChartSeries[];
+  curve?: keyof typeof CURVE_TYPE;
+  legend?: boolean;
+  valueFlags?: boolean;
+  dots?: boolean;
+  height?: number;
+  yAxisWidth?: number;
+  palette?: ChartPaletteName;
+  referenceLine?: { y: number; label?: string; band?: boolean };
+  markers?: ChartMarker[];
+  lastValueLabel?: boolean;
+  loading?: boolean;
+  valueFormatter?: (value: number) => string;
+  labelFormatter?: (label: string | number) => string;
+  className?: string;
+}
+
+function LineChart({
+  data,
+  index,
+  series,
+  curve = "monotone",
+  legend = false,
+  valueFlags = false,
+  dots = false,
+  height = 200,
+  yAxisWidth = 48,
+  palette,
+  referenceLine,
+  markers,
+  lastValueLabel = false,
+  loading = false,
+  valueFormatter = (value) => value.toLocaleString("en-US"),
+  labelFormatter,
+  className,
+}: LineChartProps) {
+  const { palette: paletteColors, theme } = useChartContext(palette);
+  const reducedMotion = useReducedMotion();
+  const animated = !reducedMotion;
+
+  const resolved = resolveSeries(series, paletteColors, theme);
+
+  const numericMax = React.useMemo(() => {
+    let max = 0;
+    for (const row of data) {
+      for (const entry of series) {
+        const value = Number(row[entry.key]);
+        if (Number.isFinite(value) && value > max) {
+          max = value;
+        }
+      }
+    }
+    return max;
+  }, [data, series]);
+
+  const curveType = CURVE_TYPE[curve];
+  const margin = { top: markers?.length ? 18 : 8, right: lastValueLabel ? 56 : 8, bottom: 2, left: 0 };
+
+  const axis = {
+    stroke: theme.border,
+    tick: { fill: theme.axisForeground, fontSize: 10, fontFamily: theme.fontMono },
+    tickLine: false as const,
+    axisLine: { stroke: theme.border, strokeOpacity: 0.6 },
+  };
+
+  const legendItems = resolved.map((entry) => ({ name: entry.name, color: entry.color, dashed: entry.dashed }));
+
+  const activeDotFor = (entry: (typeof resolved)[number]) =>
+    valueFlags
+      ? (dotProps: { cx?: number; cy?: number; value?: number | string }) => {
+          if (dotProps.cx == null || dotProps.cy == null) {
+            return <g />;
+          }
+          return (
+            <g>
+              <circle
+                cx={dotProps.cx}
+                cy={dotProps.cy}
+                r={3.5}
+                fill={entry.color}
+                stroke={theme.card}
+                strokeWidth={2}
+              />
+              <text
+                x={dotProps.cx}
+                y={dotProps.cy - 8}
+                textAnchor="middle"
+                fill={entry.color}
+                fontFamily={theme.fontMono}
+                fontSize={10}
+                style={{ fontVariantNumeric: "tabular-nums" }}
+              >
+                {valueFormatter(Number(dotProps.value ?? 0))}
+              </text>
+            </g>
+          );
+        }
+      : { r: 3.5, fill: entry.color, stroke: theme.card, strokeWidth: 2 };
+
+  const renderLastLabel =
+    (color: string) =>
+    (props: {
+      x?: string | number;
+      y?: string | number;
+      value?: string | number | boolean | Array<string | number | boolean> | null;
+      index?: number;
+    }) => {
+      if (props.index !== data.length - 1 || props.x == null || props.y == null) {
+        return null;
+      }
+      return (
+        <text
+          x={Number(props.x) + 6}
+          y={Number(props.y)}
+          dy={3}
+          fill={color}
+          fontFamily={theme.fontMono}
+          fontSize={10}
+          textAnchor="start"
+          style={{ fontVariantNumeric: "tabular-nums" }}
+        >
+          {valueFormatter(Number(props.value ?? 0))}
+        </text>
+      );
+    };
+
+  const isEmpty = data.length === 0 || resolved.length === 0;
+
+  return (
+    <div data-slot="line-chart" className={cn("flex w-full flex-col gap-3", className)}>
+      <div className="w-full" style={{ height }}>
+        {loading ? (
+          <div className="flex h-full items-center justify-center gap-2.5 font-mono text-quaternary-foreground text-text-xs">
+            <span className="size-4 animate-spin rounded-full border-2 border-border border-t-foreground" />
+            loading…
+          </div>
+        ) : isEmpty ? (
+          <div className="flex h-full items-center justify-center rounded-lg border border-border border-dashed font-mono text-quaternary-foreground text-text-xs">
+            no data in range
+          </div>
+        ) : (
+          <ResponsiveContainer width="100%" height="100%">
+            <RechartsLineChart data={data as Record<string, string | number>[]} margin={margin}>
+              <CartesianGrid vertical={false} stroke={theme.grid} strokeDasharray="2 4" />
+              <XAxis dataKey={index} {...axis} interval="preserveStartEnd" minTickGap={44} />
+              <YAxis {...axis} width={yAxisWidth} tickFormatter={(value: number) => valueFormatter(value)} />
+              <Tooltip
+                offset={12}
+                allowEscapeViewBox={{ x: false, y: false }}
+                cursor={{ stroke: theme.axisForeground, strokeWidth: 1, strokeDasharray: "3 3" }}
+                content={<ChartTooltipContent valueFormatter={valueFormatter} labelFormatter={labelFormatter} />}
+              />
+              {referenceLine?.band && (
+                <ReferenceArea
+                  y1={referenceLine.y}
+                  y2={numericMax}
+                  fill={theme.warning}
+                  fillOpacity={0.06}
+                  ifOverflow="extendDomain"
+                />
+              )}
+              {referenceLine && (
+                <ReferenceLine
+                  y={referenceLine.y}
+                  stroke={theme.warning}
+                  strokeDasharray="4 4"
+                  strokeOpacity={0.6}
+                  label={
+                    referenceLine.label
+                      ? {
+                          value: referenceLine.label,
+                          fill: theme.warning,
+                          fontSize: 9,
+                          fontFamily: theme.fontMono,
+                          position: "insideBottomRight",
+                        }
+                      : undefined
+                  }
+                />
+              )}
+
+              {resolved.map((entry) => (
+                <Line
+                  key={entry.key}
+                  type={curveType}
+                  dataKey={entry.key}
+                  name={entry.name}
+                  stroke={entry.color}
+                  strokeWidth={entry.dashed ? 2 : 1.8}
+                  strokeDasharray={entry.dashed ? "5 3" : undefined}
+                  dot={dots ? { r: 2.5, fill: entry.color, strokeWidth: 0 } : false}
+                  activeDot={activeDotFor(entry)}
+                  isAnimationActive={animated}
+                  animationDuration={650}
+                  animationEasing="ease-out"
+                >
+                  {lastValueLabel && <LabelList dataKey={entry.key} content={renderLastLabel(entry.color)} />}
+                </Line>
+              ))}
+
+              {markers?.map((marker) => (
+                <ReferenceDot
+                  key={`${marker.x}-${marker.y}`}
+                  x={marker.x}
+                  y={marker.y}
+                  r={3.5}
+                  fill={marker.color ?? theme.foreground}
+                  stroke={theme.card}
+                  strokeWidth={2}
+                  label={
+                    marker.label
+                      ? {
+                          value: marker.label,
+                          fill: marker.color ?? theme.foreground,
+                          fontSize: 9,
+                          fontFamily: theme.fontMono,
+                          position: "top",
+                        }
+                      : undefined
+                  }
+                />
+              ))}
+            </RechartsLineChart>
+          </ResponsiveContainer>
+        )}
+      </div>
+
+      {legend && !isEmpty && <ChartLegend items={legendItems} style={{ paddingLeft: yAxisWidth }} />}
+    </div>
+  );
+}
+
+export { LineChart };

package/src/components/stat.tsx

@@ -0,0 +1,109 @@
+"use client";
+
+import { cva, type VariantProps } from "class-variance-authority";
+import { ArrowDown, ArrowUp } from "lucide-react";
+import * as React from "react";
+import { Area, AreaChart, ResponsiveContainer } from "recharts";
+
+import { cn } from "../lib/cn";
+import { useChartContext } from "./chart-container";
+
+const statDeltaVariants = cva(
+  "inline-flex items-center gap-0.5 rounded-md px-1.5 py-0.5 font-mono text-[11px] font-medium leading-none",
+  {
+    variants: {
+      sentiment: {
+        positive: "text-success bg-success/12",
+        negative: "text-destructive bg-destructive/12",
+      },
+    },
+    defaultVariants: { sentiment: "positive" },
+  },
+);
+
+export interface StatDelta {
+  value: number;
+  direction: "up" | "down";
+  invert?: boolean;
+  label?: React.ReactNode;
+}
+
+export interface StatProps extends React.ComponentProps<"div"> {
+  value: React.ReactNode;
+  unit?: string;
+  delta?: StatDelta;
+  sparkline?: number[] | Array<{ value: number }>;
+}
+
+const toSparkData = (sparkline: StatProps["sparkline"]) =>
+  (sparkline ?? []).map((point, index) =>
+    typeof point === "number" ? { index, value: point } : { index, value: point.value },
+  );
+
+function Stat({ value, unit, delta, sparkline, className, ...props }: StatProps) {
+  const { palette } = useChartContext();
+  const gradientId = React.useId().replace(/:/g, "");
+  const sparkData = React.useMemo(() => toSparkData(sparkline), [sparkline]);
+  // biome-ignore lint/style/noNonNullAssertion: palettes are never empty
+  const sparkColor = palette[0]!;
+
+  const sentiment =
+    delta && (delta.invert ? delta.direction === "down" : delta.direction === "up") ? "positive" : "negative";
+
+  return (
+    <div data-slot="stat" className={cn("flex flex-col gap-2.5", className)} {...props}>
+      <div className="flex items-baseline gap-3">
+        <span className="type-display-sm font-bold leading-none tracking-tight tabular-nums text-foreground">
+          {value}
+        </span>
+        {unit && <span className="font-mono text-[11px] leading-none text-quaternary-foreground mb-0.5">{unit}</span>}
+        {delta && (
+          <DeltaPill sentiment={sentiment} className="mb-0.5">
+            {delta.direction === "up" ? <ArrowUp className="size-3" /> : <ArrowDown className="size-3" />}
+            {delta.label ?? `${delta.value}%`}
+          </DeltaPill>
+        )}
+      </div>
+      {sparkData.length > 0 && (
+        <div className="h-9 w-full">
+          <ResponsiveContainer width="100%" height="100%">
+            <AreaChart data={sparkData} margin={{ top: 4, right: 2, bottom: 0, left: 2 }}>
+              <defs>
+                <linearGradient id={gradientId} x1="0" y1="0" x2="0" y2="1">
+                  <stop offset="0%" stopColor={sparkColor} stopOpacity={0.4} />
+                  <stop offset="100%" stopColor={sparkColor} stopOpacity={0} />
+                </linearGradient>
+              </defs>
+              <Area
+                type="monotone"
+                dataKey="value"
+                stroke={sparkColor}
+                strokeWidth={1.6}
+                fill={`url(#${gradientId})`}
+                isAnimationActive={false}
+                dot={({ cx, cy, index }) => {
+                  const isLast = index === sparkData.length - 1;
+                  return isLast && cx != null && cy != null ? (
+                    <circle key={index} cx={cx} cy={cy} r={2.5} fill={sparkColor} />
+                  ) : (
+                    <g key={index} />
+                  );
+                }}
+              />
+            </AreaChart>
+          </ResponsiveContainer>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function DeltaPill({
+  sentiment,
+  className,
+  ...props
+}: React.ComponentProps<"span"> & VariantProps<typeof statDeltaVariants>) {
+  return <span className={cn(statDeltaVariants({ sentiment }), className)} {...props} />;
+}
+
+export { Stat, statDeltaVariants };