@alpic-ai/ui 0.0.0-dev.g19c2d9f → 0.0.0-dev.g1a5d5ed

package/dist/lib/chart-palette.mjs

@@ -0,0 +1,95 @@
+const CHART_PALETTES = {
+	magenta: [
+		"#e90060",
+		"#ff7eb6",
+		"#9b5de5",
+		"#5b8def",
+		"#36c5f0",
+		"#6eece7",
+		"#d98a3d",
+		"#2bb6a3"
+	],
+	cyan: [
+		"#17b8cf",
+		"#41ddc9",
+		"#3f8ff0",
+		"#8b6cf0",
+		"#c46bf0",
+		"#ff7eb6",
+		"#e90060",
+		"#c98be0"
+	]
+};
+const heatRampMagenta = (empty) => [
+	empty,
+	"#5b0a31",
+	"#a3034a",
+	"#e90060",
+	"#ff7eb6"
+];
+const heatRampMint = (empty) => [
+	empty,
+	"#0c4a52",
+	"#17b8cf",
+	"#41ddc9",
+	"#6eece7"
+];
+const HEAT_EMPTY = {
+	light: "#eef3f3",
+	dark: "#102222"
+};
+const HEAT_RAMPS = {
+	magenta: heatRampMagenta,
+	cyan: heatRampMint
+};
+const heatRamp = (palette, empty) => HEAT_RAMPS[palette](empty);
+const hexToRgb = (hex) => {
+	const value = Number.parseInt(hex.slice(1), 16);
+	return [
+		value >> 16 & 255,
+		value >> 8 & 255,
+		value & 255
+	];
+};
+const luminance = (hex) => {
+	const linear = hexToRgb(hex).map((channel) => {
+		const normalized = channel / 255;
+		return normalized <= .03928 ? normalized / 12.92 : ((normalized + .055) / 1.055) ** 2.4;
+	});
+	return .2126 * linear[0] + .7152 * linear[1] + .0722 * linear[2];
+};
+const paletteColor = (palette, index) => {
+	return palette[(index % palette.length + palette.length) % palette.length];
+};
+const RAMP_ENDS = {
+	magenta: ["#e90060", "#ff7eb6"],
+	cyan: ["#17b8cf", "#6eece7"]
+};
+const mixHex = (from, to, fraction) => {
+	const [fromR, fromG, fromB] = hexToRgb(from);
+	const [toR, toG, toB] = hexToRgb(to);
+	const ratio = Math.min(1, Math.max(0, fraction));
+	const channel = (start, end) => Math.round(start + (end - start) * ratio);
+	return `#${[
+		channel(fromR, toR),
+		channel(fromG, toG),
+		channel(fromB, toB)
+	].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+};
+const rampColor = (palette, fraction) => {
+	const [from, to] = RAMP_ENDS[palette];
+	return mixHex(from, to, fraction);
+};
+/**
+* Interpolate continuously across a multi-stop heat ramp (e.g. `heatRampMagenta`),
+* so a normalized 0..1 value reads as a smooth single-hue gradient rather than
+* the five discrete bands.
+*/
+const heatColor = (stops, fraction) => {
+	const clamped = Math.min(1, Math.max(0, fraction));
+	const segment = (stops.length - 1) * clamped;
+	const lowerIndex = Math.min(stops.length - 2, Math.floor(segment));
+	return mixHex(stops[lowerIndex], stops[lowerIndex + 1], segment - lowerIndex);
+};
+//#endregion
+export { CHART_PALETTES, HEAT_EMPTY, heatColor, heatRamp, luminance, paletteColor, rampColor };

package/dist/lib/chart.d.mts

@@ -0,0 +1,14 @@
+//#region src/lib/chart.d.ts
+/**
+ * Declarative description of one plotted series. The same shape drives area,
+ * line and bar charts — what differs is how each chart renders it.
+ */
+interface ChartSeries {
+  key: string;
+  name?: string;
+  color?: string;
+  semantic?: "error" | "warning" | "success";
+  dashed?: boolean;
+}
+//#endregion
+export { ChartSeries };

package/dist/lib/chart.mjs

@@ -0,0 +1,42 @@
+import { luminance, paletteColor } from "./chart-palette.mjs";
+import * as React$1 from "react";
+//#region src/lib/chart.ts
+const formatShare = (fraction) => `${(fraction * 100).toFixed(fraction >= .1 ? 0 : 1)}%`;
+const semanticColor = (theme, semantic) => {
+	if (semantic === "error") return theme.destructive;
+	if (semantic === "warning") return theme.warning;
+	return theme.success;
+};
+/**
+* Resolve each series to a concrete color and name. Color precedence:
+* explicit `color` → `semantic` token → palette slot by declared index (so the
+* lead series keeps the lead color even after the bands are reordered).
+*/
+const resolveSeries = (series, palette, theme) => series.map((entry, index) => ({
+	...entry,
+	name: entry.name ?? entry.key,
+	color: entry.color ?? (entry.semantic ? semanticColor(theme, entry.semantic) : paletteColor(palette, index))
+}));
+/**
+* Stacked bands read cleanest as a vertical gradient: darkest at the baseline,
+* lightest at the top edge. Sorting by luminance enforces that for any palette
+* (this is what fixed the "muddy cyan" stack in the lab). Render order maps to
+* stack order in Recharts — first entry sits at the bottom.
+*/
+const orderByLuminance = (series) => [...series].sort((lower, upper) => luminance(lower.color) - luminance(upper.color));
+const makeXAxisTick = (theme) => ({ x, y, payload, index, visibleTicksCount }) => {
+	const isFirst = index === 0;
+	const isLast = visibleTicksCount != null && index === visibleTicksCount - 1;
+	const anchor = isFirst ? "start" : isLast ? "end" : "middle";
+	return React$1.createElement("text", {
+		x: Number(x ?? 0),
+		y: Number(y ?? 0),
+		dy: 12,
+		textAnchor: anchor,
+		fill: theme.axisForeground,
+		fontFamily: theme.fontMono,
+		fontSize: 10
+	}, String(payload?.value ?? ""));
+};
+//#endregion
+export { formatShare, makeXAxisTick, orderByLuminance, resolveSeries };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alpic-ai/ui",
-  "version": "0.0.0-dev.g19c2d9f",
+  "version": "0.0.0-dev.g1a5d5ed",
   "description": "Alpic design system — shared UI components",
   "type": "module",
   "exports": {
@@ -23,48 +23,49 @@
     "src"
   ],
   "peerDependencies": {
-    "lucide-react": "^1.14.0",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
-    "react-hook-form": "^7.75.0",
+    "lucide-react": "^1.21.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "react-hook-form": "^7.80.0",
     "sonner": "^2.0.7",
-    "tailwindcss": "^4.3.0",
+    "tailwindcss": "^4.3.1",
     "tw-animate-css": "^1.4.0"
   },
   "dependencies": {
-    "@radix-ui/react-accordion": "^1.2.12",
-    "@radix-ui/react-avatar": "^1.1.11",
-    "@radix-ui/react-checkbox": "^1.3.3",
-    "@radix-ui/react-collapsible": "^1.1.12",
-    "@radix-ui/react-dialog": "^1.1.15",
-    "@radix-ui/react-dropdown-menu": "^2.1.16",
-    "@radix-ui/react-label": "^2.1.8",
-    "@radix-ui/react-popover": "^1.1.15",
-    "@radix-ui/react-radio-group": "^1.3.8",
-    "@radix-ui/react-scroll-area": "^1.2.10",
-    "@radix-ui/react-select": "^2.2.6",
-    "@radix-ui/react-separator": "^1.1.8",
-    "@radix-ui/react-slot": "^1.2.4",
-    "@radix-ui/react-switch": "^1.2.6",
-    "@radix-ui/react-tabs": "^1.1.13",
-    "@radix-ui/react-toggle-group": "^1.1.11",
-    "@radix-ui/react-tooltip": "^1.2.8",
+    "@radix-ui/react-accordion": "^1.2.14",
+    "@radix-ui/react-avatar": "^1.2.0",
+    "@radix-ui/react-checkbox": "^1.3.5",
+    "@radix-ui/react-collapsible": "^1.1.14",
+    "@radix-ui/react-dialog": "^1.1.17",
+    "@radix-ui/react-dropdown-menu": "^2.1.18",
+    "@radix-ui/react-label": "^2.1.10",
+    "@radix-ui/react-popover": "^1.1.17",
+    "@radix-ui/react-radio-group": "^1.4.1",
+    "@radix-ui/react-scroll-area": "^1.2.12",
+    "@radix-ui/react-select": "^2.3.1",
+    "@radix-ui/react-separator": "^1.1.10",
+    "@radix-ui/react-slot": "^1.3.0",
+    "@radix-ui/react-switch": "^1.3.1",
+    "@radix-ui/react-tabs": "^1.1.15",
+    "@radix-ui/react-toggle-group": "^1.1.13",
+    "@radix-ui/react-tooltip": "^1.2.10",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
+    "recharts": "^3.8.1",
     "tailwind-merge": "^3.6.0"
   },
   "devDependencies": {
     "@ladle/react": "^5.1.1",
-    "@tailwindcss/postcss": "^4.3.0",
-    "@types/react": "19.2.14",
+    "@tailwindcss/postcss": "^4.3.1",
+    "@types/react": "19.2.17",
     "@types/react-dom": "19.2.3",
-    "lucide-react": "^1.14.0",
-    "react-hook-form": "^7.75.0",
+    "lucide-react": "^1.21.0",
+    "react-hook-form": "^7.80.0",
     "shx": "^0.4.0",
     "sonner": "^2.0.7",
-    "tailwindcss": "^4.3.0",
-    "tsdown": "^0.22.0",
+    "tailwindcss": "^4.3.1",
+    "tsdown": "^0.22.3",
     "tw-animate-css": "^1.4.0",
     "typescript": "^6.0.3"
   },

package/src/components/area-chart.tsx

@@ -0,0 +1,347 @@
+"use client";
+
+import * as React from "react";
+import {
+  Area,
+  CartesianGrid,
+  LabelList,
+  AreaChart as RechartsAreaChart,
+  ReferenceArea,
+  ReferenceDot,
+  ReferenceLine,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from "recharts";
+
+import { useReducedMotion } from "../hooks/use-reduced-motion";
+import { type ChartSeries, makeXAxisTick, orderByLuminance, resolveSeries } from "../lib/chart";
+import type { ChartPaletteName } from "../lib/chart-palette";
+import { cn } from "../lib/cn";
+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 ChartMarker {
+  x: string | number;
+  y: number;
+  label?: string;
+  color?: string;
+}
+
+export interface AreaChartProps {
+  data: ReadonlyArray<Record<string, string | number | null | undefined>>;
+  index: string;
+  series: ChartSeries[];
+  variant?: "stacked" | "grouped" | "expand";
+  curve?: keyof typeof CURVE_TYPE;
+  legend?: boolean;
+  legendAlign?: "left" | "center" | "right";
+  valueFlags?: boolean;
+  height?: number;
+  yAxisWidth?: number;
+  palette?: ChartPaletteName;
+  referenceLine?: { y: number; label?: string; band?: boolean };
+  markers?: ChartMarker[];
+  lastValueLabel?: boolean;
+  texture?: boolean;
+  loading?: boolean;
+  valueFormatter?: (value: number) => string;
+  labelFormatter?: (label: string | number) => string;
+  className?: string;
+}
+
+function AreaChart({
+  data,
+  index,
+  series,
+  variant = "stacked",
+  curve = "monotone",
+  legend = false,
+  legendAlign = "left",
+  valueFlags = false,
+  height = 200,
+  yAxisWidth = 48,
+  palette,
+  referenceLine,
+  markers,
+  lastValueLabel = false,
+  texture = false,
+  loading = false,
+  valueFormatter = (value) => value.toLocaleString("en-US"),
+  labelFormatter,
+  className,
+}: AreaChartProps) {
+  const { palette: paletteColors, theme } = useChartContext(palette);
+  const reactId = React.useId().replace(/:/g, "");
+  const reducedMotion = useReducedMotion();
+  const animated = !reducedMotion;
+
+  const resolved = resolveSeries(series, paletteColors, theme);
+  const stacked = variant === "stacked" || variant === "expand";
+  const rendered = stacked ? orderByLuminance(resolved) : resolved;
+
+  const strokeOnly = variant === "grouped" && rendered.length > 1;
+  const filled = !strokeOnly;
+  const lead = resolved[0];
+  const withTotal = stacked && rendered.length > 1;
+
+  // Stacked bands must reach the stack height (sum per x-point), not the tallest
+  // single series, or the reference band stops short of the chart top.
+  const numericMax = React.useMemo(() => {
+    let max = 0;
+    for (const row of data) {
+      let rowTotal = 0;
+      for (const entry of series) {
+        const value = Number(row[entry.key]);
+        if (Number.isFinite(value)) {
+          rowTotal += value;
+          if (!stacked && value > max) {
+            max = value;
+          }
+        }
+      }
+      if (stacked && rowTotal > max) {
+        max = rowTotal;
+      }
+    }
+    return max;
+  }, [data, series, stacked]);
+
+  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 rendered)[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 fillFor = (entry: (typeof rendered)[number], slot: number) => {
+    if (!filled) {
+      return "none";
+    }
+    if (texture && lead && entry.key === lead.key) {
+      return `url(#hatch-${reactId})`;
+    }
+    return `url(#area-${reactId}-${slot})`;
+  };
+
+  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 || rendered.length === 0;
+
+  return (
+    <div data-slot="area-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%" initialDimension={{ width: 0, height }}>
+            <RechartsAreaChart
+              data={data as Record<string, string | number>[]}
+              stackOffset={variant === "expand" ? "expand" : "none"}
+              margin={margin}
+            >
+              <defs>
+                {filled &&
+                  rendered.map((entry, slot) => (
+                    <linearGradient key={entry.key} id={`area-${reactId}-${slot}`} x1="0" y1="0" x2="0" y2="1">
+                      <stop offset="0%" stopColor={entry.color} stopOpacity={stacked ? 0.78 : 0.5} />
+                      <stop offset="100%" stopColor={entry.color} stopOpacity={stacked ? 0.32 : 0.04} />
+                    </linearGradient>
+                  ))}
+                {texture && filled && lead && (
+                  <pattern
+                    id={`hatch-${reactId}`}
+                    patternUnits="userSpaceOnUse"
+                    width={6}
+                    height={6}
+                    patternTransform="rotate(45)"
+                  >
+                    <rect width={6} height={6} fill={lead.color} fillOpacity={0.18} />
+                    <line x1={0} y1={0} x2={0} y2={6} stroke={lead.color} strokeWidth={1.2} strokeOpacity={0.6} />
+                  </pattern>
+                )}
+              </defs>
+
+              <CartesianGrid vertical={false} stroke={theme.grid} strokeDasharray="2 4" />
+              <XAxis
+                dataKey={index}
+                {...axis}
+                tick={makeXAxisTick(theme)}
+                interval="preserveStartEnd"
+                minTickGap={44}
+              />
+              <YAxis
+                {...axis}
+                width={yAxisWidth}
+                tickFormatter={(value: number) =>
+                  variant === "expand" ? `${Math.round(value * 100)}%` : 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}
+                    showTotal={withTotal}
+                  />
+                }
+              />
+              {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
+                  }
+                />
+              )}
+
+              {rendered.map((entry, slot) => (
+                <Area
+                  key={entry.key}
+                  type={curveType}
+                  dataKey={entry.key}
+                  name={entry.name}
+                  stackId={stacked ? "stack" : undefined}
+                  stroke={entry.color}
+                  strokeWidth={entry.dashed ? 2 : 1.6}
+                  strokeDasharray={entry.dashed ? "5 3" : undefined}
+                  fill={fillFor(entry, slot)}
+                  dot={false}
+                  activeDot={activeDotFor(entry)}
+                  isAnimationActive={animated}
+                  animationDuration={650}
+                  animationEasing="ease-out"
+                >
+                  {lastValueLabel && <LabelList dataKey={entry.key} content={renderLastLabel(entry.color)} />}
+                </Area>
+              ))}
+
+              {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
+                  }
+                />
+              ))}
+            </RechartsAreaChart>
+          </ResponsiveContainer>
+        )}
+      </div>
+
+      {legend && !isEmpty && <ChartLegend items={legendItems} align={legendAlign} insetLeft={yAxisWidth} />}
+    </div>
+  );
+}
+
+export { AreaChart };