@hilum/ui 3.2.3 → 3.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hilum/ui",
-  "version": "3.2.3",
+  "version": "3.2.5",
   "private": false,
   "description": "Hilum UI — design system primitives (Button, Input, Dialog, Combobox, …) + tokens + fonts + icons",
   "license": "MIT",

package/src/components/alert-dialog.tsx

@@ -3,6 +3,11 @@
 import * as React from "react";
 import { AlertDialog } from "radix-ui";
 import { cn } from "../lib/utils";
+import {
+  desktopDialogContentClassName,
+  dialogSheetMotionClassName,
+  mobileDialogSheetContentClassName,
+} from "../lib/mobile-popper-sheet";
 
 const AlertDialogRoot = AlertDialog.Root;
 const AlertDialogTrigger = AlertDialog.Trigger;
@@ -34,11 +39,10 @@ const AlertDialogContent = React.forwardRef<
     <AlertDialog.Content
       ref={ref}
       className={cn(
-        "fixed left-[50%] top-[50%] z-50 translate-x-[-50%] translate-y-[-50%]",
-        "w-full max-w-md bg-card rounded-2xl shadow-elevated p-6",
-        "data-[state=open]:animate-in data-[state=closed]:animate-out",
-        "data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
-        "data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95",
+        mobileDialogSheetContentClassName,
+        desktopDialogContentClassName,
+        "sm:max-w-md",
+        dialogSheetMotionClassName,
         className,
       )}
       {...props}
@@ -55,7 +59,16 @@ function AlertDialogHeader({ className, ...props }: React.HTMLAttributes<HTMLDiv
 AlertDialogHeader.displayName = "AlertDialogHeader";
 
 function AlertDialogFooter({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) {
-  return <div className={cn("flex items-center justify-end gap-2 mt-6", className)} {...props} />;
+  return (
+    <div
+      className={cn(
+        "mt-6 flex flex-col-reverse gap-2 sm:flex-row sm:items-center sm:justify-end",
+        "[&>*]:w-full sm:[&>*]:w-auto",
+        className,
+      )}
+      {...props}
+    />
+  );
 }
 AlertDialogFooter.displayName = "AlertDialogFooter";
 

package/src/components/callout.tsx

@@ -0,0 +1,99 @@
+import * as React from "react";
+import { cva, type VariantProps } from "class-variance-authority";
+import { cn } from "../lib/utils";
+
+const calloutVariants = cva(
+  "flex w-full min-w-0 gap-3 rounded-xl border px-4 py-3.5 shadow-natural",
+  {
+    variants: {
+      tone: {
+        default: "border-border bg-card text-foreground",
+        info: "border-brand-secondary/50 bg-brand-secondary/15 text-foreground",
+        success: "border-success/25 bg-success/10 text-foreground",
+        warning: "border-warning/35 bg-warning/15 text-foreground",
+        destructive: "border-destructive/25 bg-destructive/10 text-foreground",
+      },
+      compact: {
+        true: "px-3 py-2.5",
+        false: "",
+      },
+    },
+    defaultVariants: {
+      tone: "default",
+      compact: false,
+    },
+  },
+);
+
+const calloutIconVariants = cva(
+  "mt-0.5 flex size-9 shrink-0 items-center justify-center rounded-lg [&_svg]:size-4",
+  {
+    variants: {
+      tone: {
+        default: "bg-muted text-muted-foreground",
+        info: "bg-brand-secondary/35 text-muted-foreground",
+        success: "bg-success/15 text-success",
+        warning: "bg-warning/20 text-warning",
+        destructive: "bg-destructive/15 text-destructive",
+      },
+    },
+    defaultVariants: {
+      tone: "default",
+    },
+  },
+);
+
+interface CalloutProps
+  extends Omit<React.ComponentProps<"div">, "title">,
+    VariantProps<typeof calloutVariants> {
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  icon?: React.ReactNode;
+  actions?: React.ReactNode;
+}
+
+function Callout({
+  title,
+  description,
+  icon,
+  actions,
+  tone = "default",
+  compact = false,
+  className,
+  children,
+  role,
+  ...props
+}: CalloutProps) {
+  const resolvedRole = role ?? (tone === "destructive" ? "alert" : "status");
+
+  return (
+    <div
+      role={resolvedRole}
+      className={cn(calloutVariants({ tone, compact }), className)}
+      {...props}
+    >
+      {icon && <div className={cn(calloutIconVariants({ tone }))}>{icon}</div>}
+      <div className="flex min-w-0 flex-1 flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+        <div className="min-w-0">
+          {title && <p className="body font-semibold text-balance">{title}</p>}
+          {description && (
+            <p className={cn("body text-pretty text-muted-foreground", title && "mt-1")}>
+              {description}
+            </p>
+          )}
+          {children && <div className={cn(title || description ? "mt-2" : "")}>{children}</div>}
+        </div>
+        {actions && (
+          <div className="flex shrink-0 items-center gap-2 max-sm:w-full max-sm:flex-col max-sm:items-stretch">
+            {actions}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+Callout.displayName = "Callout";
+
+export { Callout };
+export type { CalloutProps };

package/src/components/card.tsx

@@ -92,6 +92,18 @@ const CardFooter = React.forwardRef<HTMLDivElement, React.ComponentProps<"div">>
 );
 CardFooter.displayName = "CardFooter";
 
+const CardAction = React.forwardRef<HTMLDivElement, React.ComponentProps<"div">>(
+  ({ className, ...props }, ref) => (
+    <div
+      ref={ref}
+      data-slot="card-action"
+      className={cn("col-start-2 row-span-2 row-start-1 self-start justify-self-end", className)}
+      {...props}
+    />
+  ),
+);
+CardAction.displayName = "CardAction";
+
 /* ------------------------------------------------------------------ */
 /*  CardMedia — full-bleed image/gradient header                       */
 /* ------------------------------------------------------------------ */
@@ -115,6 +127,7 @@ export {
   CardDescription,
   CardContent,
   CardFooter,
+  CardAction,
   CardMedia,
   cardVariants,
 };

package/src/components/chart.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import * as React from "react";
-import { ResponsiveContainer, type TooltipContentProps } from "recharts";
+import * as RechartsPrimitive from "recharts";
 import { cn } from "../lib/utils";
 import { tokens } from "../tokens/tokens";
 
@@ -14,49 +14,418 @@ export const CHART_COLORS = {
   dark: tokens.semantic.light.foreground,
 };
 
-interface ChartContainerProps {
-  children: React.ReactNode;
-  className?: string;
-  height?: number;
+const THEMES = { light: "", dark: ".dark" } as const;
+
+export type ChartConfig = {
+  [k in string]: {
+    label?: React.ReactNode;
+    icon?: React.ComponentType;
+  } & (
+    | { color?: string; theme?: never }
+    | { color?: never; theme: Record<keyof typeof THEMES, string> }
+  );
+};
+
+type ChartContextProps = {
+  config: ChartConfig;
+};
+
+const ChartContext = React.createContext<ChartContextProps | null>(null);
+
+function useChart() {
+  const context = React.useContext(ChartContext);
+
+  if (!context) {
+    throw new Error("useChart must be used within a <ChartContainer />");
+  }
+
+  return context;
 }
 
-function ChartContainer({ children, className, height = 300 }: ChartContainerProps) {
+type ChartContainerProps = React.ComponentProps<"div"> & {
+  config?: ChartConfig;
+  height?: number;
+  children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+};
+
+function ChartContainer({
+  id,
+  className,
+  children,
+  config = {},
+  height,
+  style,
+  ...props
+}: ChartContainerProps) {
+  const uniqueId = React.useId();
+  const chartId = `chart-${id || uniqueId.replace(/:/g, "")}`;
+  const resolvedStyle =
+    height === undefined ? style : ({ ...style, height } as React.CSSProperties);
+
   return (
-    <div className={cn("w-full", className)}>
-      <ResponsiveContainer width="100%" height={height}>
-        {children as React.ReactElement}
-      </ResponsiveContainer>
-    </div>
+    <ChartContext.Provider value={{ config }}>
+      <div
+        data-slot="chart"
+        data-chart={chartId}
+        className={cn(
+          "flex aspect-video justify-center text-xs",
+          "[&_.recharts-cartesian-axis-tick_text]:fill-muted-foreground",
+          "[&_.recharts-cartesian-grid_line[stroke='#ccc']]:stroke-border/50",
+          "[&_.recharts-curve.recharts-tooltip-cursor]:stroke-border",
+          "[&_.recharts-dot[stroke='#fff']]:stroke-transparent",
+          "[&_.recharts-layer]:outline-hidden",
+          "[&_.recharts-polar-grid_[stroke='#ccc']]:stroke-border",
+          "[&_.recharts-radial-bar-background-sector]:fill-muted",
+          "[&_.recharts-rectangle.recharts-tooltip-cursor]:fill-muted",
+          "[&_.recharts-reference-line_[stroke='#ccc']]:stroke-border",
+          "[&_.recharts-sector]:outline-hidden",
+          "[&_.recharts-sector[stroke='#fff']]:stroke-transparent",
+          "[&_.recharts-surface]:outline-hidden",
+          className,
+        )}
+        style={resolvedStyle}
+        {...props}
+      >
+        <ChartStyle id={chartId} config={config} />
+        <RechartsPrimitive.ResponsiveContainer>
+          {children}
+        </RechartsPrimitive.ResponsiveContainer>
+      </div>
+    </ChartContext.Provider>
   );
 }
 ChartContainer.displayName = "ChartContainer";
 
-// Custom tooltip component styled to match the design system
-interface ChartTooltipProps extends Partial<TooltipContentProps<number, string>> {
-  labelClassName?: string;
+const ChartStyle = ({ id, config }: { id: string; config: ChartConfig }) => {
+  const colorConfig = Object.entries(config).filter(
+    ([, itemConfig]) => itemConfig.theme || itemConfig.color,
+  );
+
+  if (!colorConfig.length) {
+    return null;
+  }
+
+  return (
+    <style
+      dangerouslySetInnerHTML={{
+        __html: Object.entries(THEMES)
+          .map(
+            ([theme, prefix]) => `
+${prefix} [data-chart=${id}] {
+${colorConfig
+  .map(([key, itemConfig]) => {
+    const color =
+      itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ||
+      itemConfig.color;
+    return color ? `  --color-${key}: ${color};` : null;
+  })
+  .join("\n")}
 }
+`,
+          )
+          .join("\n"),
+      }}
+    />
+  );
+};
 
-function ChartTooltip({ active, payload, label, labelClassName }: ChartTooltipProps) {
-  if (!active || !payload?.length) return null;
+type ChartTooltipContentProps = Omit<
+  React.HTMLAttributes<HTMLDivElement>,
+  "children" | "content"
+> & {
+  active?: boolean;
+  payload?: Array<Record<string, any>>;
+  indicator?: "line" | "dot" | "dashed";
+  hideLabel?: boolean;
+  hideIndicator?: boolean;
+  label?: React.ReactNode;
+  labelFormatter?: (
+    value: React.ReactNode,
+    payload: Array<Record<string, any>>,
+  ) => React.ReactNode;
+  labelClassName?: string;
+  formatter?: (
+    value: unknown,
+    name: unknown,
+    item: Record<string, any>,
+    index: number,
+    payload: unknown,
+  ) => React.ReactNode;
+  color?: string;
+  nameKey?: string;
+  labelKey?: string;
+};
+
+type ChartTooltipProps =
+  | React.ComponentProps<typeof RechartsPrimitive.Tooltip>
+  | ChartTooltipContentProps;
+
+function ChartTooltip(props: ChartTooltipProps) {
+  const hasDirectTooltipPayload = "active" in props || "payload" in props;
+  if (hasDirectTooltipPayload) {
+    return <ChartTooltipContent {...(props as ChartTooltipContentProps)} />;
+  }
   return (
-    <div className="rounded-xl border border-border bg-card px-3 py-2 shadow-elevated">
-      {label && <p className={cn("mb-1 label text-muted-foreground", labelClassName)}>{label}</p>}
-      {payload.map((entry, i) => (
-        <div key={i} className="flex items-center gap-2">
-          <span
-            className="inline-block h-2 w-2 rounded-full"
-            style={{ backgroundColor: entry.color }}
-          />
-          <span className="caption text-muted-foreground">{entry.name}:</span>
-          <span className="caption font-medium text-foreground">{entry.value}</span>
+    <RechartsPrimitive.Tooltip
+      {...(props as React.ComponentProps<typeof RechartsPrimitive.Tooltip>)}
+    />
+  );
+}
+ChartTooltip.displayName = "ChartTooltip";
+
+function ChartTooltipContent({
+  active,
+  payload,
+  className,
+  indicator = "dot",
+  hideLabel = false,
+  hideIndicator = false,
+  label,
+  labelFormatter,
+  labelClassName,
+  formatter,
+  color,
+  nameKey,
+  labelKey,
+}: ChartTooltipContentProps) {
+  const chartContext = React.useContext(ChartContext);
+  const config = chartContext?.config ?? {};
+
+  const tooltipLabel = React.useMemo(() => {
+    if (hideLabel || !payload?.length) {
+      return null;
+    }
+
+    const [item] = payload;
+    const key = `${labelKey || item?.dataKey || item?.name || "value"}`;
+    const itemConfig = getPayloadConfigFromPayload(config, item, key);
+    const value =
+      !labelKey && typeof label === "string"
+        ? config[label as keyof typeof config]?.label || label
+        : itemConfig?.label;
+
+    if (labelFormatter) {
+      return (
+        <div className={cn("font-medium", labelClassName)}>
+          {labelFormatter(value, payload)}
         </div>
-      ))}
+      );
+    }
+
+    if (!value) {
+      return null;
+    }
+
+    return <div className={cn("font-medium", labelClassName)}>{value}</div>;
+  }, [
+    label,
+    labelFormatter,
+    payload,
+    hideLabel,
+    labelClassName,
+    config,
+    labelKey,
+  ]);
+
+  if (!active || !payload?.length) {
+    return null;
+  }
+
+  const nestLabel = payload.length === 1 && indicator !== "dot";
+
+  return (
+    <div
+      className={cn(
+        "grid min-w-[8rem] items-start gap-1.5 rounded-lg border border-border/50 bg-background px-2.5 py-1.5 text-xs shadow-xl",
+        className,
+      )}
+    >
+      {!nestLabel ? tooltipLabel : null}
+      <div className="grid gap-1.5">
+        {payload.map((item: Record<string, any>, index: number) => {
+          const key = `${nameKey || item.name || item.dataKey || "value"}`;
+          const itemConfig = getPayloadConfigFromPayload(config, item, key);
+          const itemPayload = item.payload as Record<string, unknown> | undefined;
+          const indicatorColor =
+            color ||
+            (typeof itemPayload?.fill === "string" ? itemPayload.fill : undefined) ||
+            item.color;
+
+          return (
+            <div
+              key={`${item.dataKey || item.name || index}`}
+              className={cn(
+                "flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground",
+                indicator === "dot" && "items-center",
+              )}
+            >
+              {formatter && item?.value !== undefined && item.name ? (
+                formatter(item.value, item.name, item, index, item.payload)
+              ) : (
+                <>
+                  {itemConfig?.icon ? (
+                    <itemConfig.icon />
+                  ) : (
+                    !hideIndicator && (
+                      <div
+                        className={cn(
+                          "shrink-0 rounded-[2px] border-(--color-border) bg-(--color-bg)",
+                          {
+                            "h-2.5 w-2.5": indicator === "dot",
+                            "w-1": indicator === "line",
+                            "w-0 border-[1.5px] border-dashed bg-transparent":
+                              indicator === "dashed",
+                            "my-0.5": nestLabel && indicator === "dashed",
+                          },
+                        )}
+                        style={
+                          {
+                            "--color-bg": indicatorColor,
+                            "--color-border": indicatorColor,
+                          } as React.CSSProperties
+                        }
+                      />
+                    )
+                  )}
+                  <div
+                    className={cn(
+                      "flex flex-1 justify-between leading-none",
+                      nestLabel ? "items-end" : "items-center",
+                    )}
+                  >
+                    <div className="grid gap-1.5">
+                      {nestLabel ? tooltipLabel : null}
+                      <span className="text-muted-foreground">
+                        {itemConfig?.label || item.name}
+                      </span>
+                    </div>
+                    {item.value !== undefined && item.value !== null && (
+                      <span className="font-mono font-medium tabular-nums text-foreground">
+                        {typeof item.value === "number"
+                          ? item.value.toLocaleString()
+                          : item.value}
+                      </span>
+                    )}
+                  </div>
+                </>
+              )}
+            </div>
+          );
+        })}
+      </div>
     </div>
   );
 }
-ChartTooltip.displayName = "ChartTooltip";
+ChartTooltipContent.displayName = "ChartTooltipContent";
+
+const ChartLegend = RechartsPrimitive.Legend;
+
+type ChartLegendPayloadItem = {
+  color?: string;
+  dataKey?: string | number;
+  value?: string | number;
+};
+
+function ChartLegendContent({
+  className,
+  hideIcon = false,
+  payload,
+  verticalAlign = "bottom",
+  nameKey,
+}: Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & {
+  hideIcon?: boolean;
+  nameKey?: string;
+  payload?: ChartLegendPayloadItem[];
+  verticalAlign?: "top" | "middle" | "bottom";
+}) {
+  const { config } = useChart();
 
-export { ChartContainer, ChartTooltip };
+  if (!payload?.length) {
+    return null;
+  }
+
+  return (
+    <div
+      className={cn(
+        "flex items-center justify-center gap-4",
+        verticalAlign === "top" ? "pb-3" : "pt-3",
+        className,
+      )}
+    >
+      {payload.map((item: ChartLegendPayloadItem) => {
+        const key = `${nameKey || item.dataKey || "value"}`;
+        const itemConfig = getPayloadConfigFromPayload(config, item, key);
+
+        return (
+          <div
+            key={`${item.value}`}
+            className="flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground"
+          >
+            {itemConfig?.icon && !hideIcon ? (
+              <itemConfig.icon />
+            ) : (
+              <div
+                className="h-2 w-2 shrink-0 rounded-[2px]"
+                style={{
+                  backgroundColor: item.color,
+                }}
+              />
+            )}
+            {itemConfig?.label}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+ChartLegendContent.displayName = "ChartLegendContent";
+
+function getPayloadConfigFromPayload(
+  config: ChartConfig,
+  payload: unknown,
+  key: string,
+) {
+  if (typeof payload !== "object" || payload === null) {
+    return undefined;
+  }
+
+  const payloadPayload =
+    "payload" in payload &&
+    typeof payload.payload === "object" &&
+    payload.payload !== null
+      ? payload.payload
+      : undefined;
+
+  let configLabelKey: string = key;
+
+  if (
+    key in payload &&
+    typeof payload[key as keyof typeof payload] === "string"
+  ) {
+    configLabelKey = payload[key as keyof typeof payload] as string;
+  } else if (
+    payloadPayload &&
+    key in payloadPayload &&
+    typeof payloadPayload[key as keyof typeof payloadPayload] === "string"
+  ) {
+    configLabelKey = payloadPayload[
+      key as keyof typeof payloadPayload
+    ] as string;
+  }
+
+  return configLabelKey in config
+    ? config[configLabelKey]
+    : config[key as keyof typeof config];
+}
+
+export {
+  ChartContainer,
+  ChartTooltip,
+  ChartTooltipContent,
+  ChartLegend,
+  ChartLegendContent,
+  ChartStyle,
+};
 
 export {
   BarChart,