@mihcm/ui 0.14.1

package/src/Chart.tsx

@@ -0,0 +1,467 @@
+'use client';
+
+/**
+ * Chart (web only — React DOM).
+ *
+ * Theme-aware Recharts wrapper. Provides a context-based config system
+ * that maps data keys to labels, icons, and colors (with light/dark
+ * theme support via CSS custom properties).
+ *
+ * Exports:
+ *  - `ChartContainer` — wraps `ResponsiveContainer`, injects CSS vars
+ *  - `ChartTooltip` — re-export of `recharts.Tooltip`
+ *  - `ChartTooltipContent` — styled tooltip with indicator variants
+ *  - `ChartLegend` — re-export of `recharts.Legend`
+ *  - `ChartLegendContent` — styled legend items with optional icons
+ *  - `ChartStyle` — CSS variable injection for light/dark themes
+ *  - `ChartConfig` type — config shape for data-key → label/icon/color
+ *  - `useChart` hook — access chart config from context
+ *
+ * Wiki: docs/components/Chart.md
+ */
+import {
+  createContext,
+  useContext,
+  useId,
+  useMemo,
+  forwardRef,
+  type ComponentProps,
+  type ComponentType,
+  type CSSProperties,
+  type ReactNode,
+} from 'react';
+import * as RechartsPrimitive from 'recharts';
+import type { TooltipValueType } from 'recharts';
+import { cn } from './internal/cn.js';
+
+/* -------------------------------------------------------------------------- */
+/*  Theme map                                                                 */
+/* -------------------------------------------------------------------------- */
+
+/** CSS selector per theme. Light = root scope, dark = `.dark` class. */
+const THEMES = { light: '', dark: '.dark' } as const;
+
+const INITIAL_DIMENSION = { width: 320, height: 200 } as const;
+const DEFAULT_CHART_COLORS = [
+  'var(--color-primary, #003385)',
+  'var(--color-accent, #eb6a2a)',
+  'var(--color-success, #2f7d32)',
+  'var(--color-warning, #b26a00)',
+  'var(--color-brand-neutral-436, #5f6f82)',
+  'var(--color-danger, #b42318)',
+] as const;
+
+type TooltipNameType = number | string;
+
+/* -------------------------------------------------------------------------- */
+/*  ChartConfig type                                                          */
+/* -------------------------------------------------------------------------- */
+
+export type ChartConfig = Record<
+  string,
+  {
+    label?: ReactNode;
+    icon?: ComponentType;
+  } & (
+    | { color?: string; theme?: never }
+    | { color?: never; theme: Record<keyof typeof THEMES, string> }
+  )
+>;
+
+/* -------------------------------------------------------------------------- */
+/*  Context                                                                   */
+/* -------------------------------------------------------------------------- */
+
+interface ChartContextProps {
+  config: ChartConfig;
+}
+
+const ChartContext = createContext<ChartContextProps | null>(null);
+
+export function useChart(): ChartContextProps {
+  const context = useContext(ChartContext);
+  if (!context) {
+    throw new Error('useChart must be used within a <ChartContainer />');
+  }
+  return context;
+}
+
+/* -------------------------------------------------------------------------- */
+/*  ChartContainer                                                            */
+/* -------------------------------------------------------------------------- */
+
+export interface ChartContainerProps extends ComponentProps<'div'> {
+  config: ChartConfig;
+  children: ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>['children'];
+  initialDimension?: { width: number; height: number };
+}
+
+export const ChartContainer = forwardRef<HTMLDivElement, ChartContainerProps>(
+  function ChartContainer(
+    { id, className, children, config, initialDimension = INITIAL_DIMENSION, ...props },
+    ref,
+  ) {
+    const uniqueId = useId();
+    const chartId = `chart-${id ?? uniqueId.replace(/:/g, '')}`;
+
+    return (
+      <ChartContext.Provider value={{ config }}>
+        <div
+          ref={ref}
+          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,
+          )}
+          {...props}
+        >
+          <ChartStyle id={chartId} config={config} />
+          <RechartsPrimitive.ResponsiveContainer initialDimension={initialDimension}>
+            {children}
+          </RechartsPrimitive.ResponsiveContainer>
+        </div>
+      </ChartContext.Provider>
+    );
+  },
+);
+
+/* -------------------------------------------------------------------------- */
+/*  ChartStyle                                                                */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Injects CSS custom properties (`--color-<key>`) for each config entry,
+ * scoped to the chart's `[data-chart]` selector.
+ *
+ * NOTE: The `<style>` content is derived entirely from developer-controlled
+ * `ChartConfig` — not user input — so inline style injection is safe here.
+ */
+export function ChartStyle({ id, config }: { id: string; config: ChartConfig }) {
+  const colorConfig = Object.entries(config);
+
+  if (!colorConfig.length) {
+    return null;
+  }
+
+  const cssText = Object.entries(THEMES)
+    .map(
+      ([theme, prefix]) => `
+${prefix} [data-chart=${id}] {
+${colorConfig
+  .map(([key, itemConfig], index) => {
+    const fallbackColor = getDefaultChartColor(index);
+    const color =
+      itemConfig.theme?.[theme as keyof typeof itemConfig.theme] ?? itemConfig.color;
+    return `  --color-${key}: ${withCssVarFallback(color, fallbackColor)};`;
+  })
+  .join('\n')}
+}
+`,
+    )
+    .join('\n');
+
+  return <style>{cssText}</style>;
+}
+
+/* -------------------------------------------------------------------------- */
+/*  ChartTooltip + ChartTooltipContent                                       */
+/* -------------------------------------------------------------------------- */
+
+export const ChartTooltip = RechartsPrimitive.Tooltip;
+
+export function ChartTooltipContent({
+  active,
+  payload,
+  className,
+  indicator = 'dot',
+  hideLabel = false,
+  hideIndicator = false,
+  label,
+  labelFormatter,
+  labelClassName,
+  formatter,
+  color,
+  nameKey,
+  labelKey,
+}: ComponentProps<typeof RechartsPrimitive.Tooltip> &
+  ComponentProps<'div'> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: 'line' | 'dot' | 'dashed';
+    nameKey?: string;
+    labelKey?: string;
+  } & Omit<
+    RechartsPrimitive.DefaultTooltipContentProps<TooltipValueType, TooltipNameType>,
+    'accessibilityLayer'
+  >) {
+  const { config } = useChart();
+
+  const tooltipLabel = 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]?.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
+          .filter((item) => item.type !== 'none')
+          .map((item, index) => {
+            const key = `${nameKey ?? item.name ?? item.dataKey ?? 'value'}`;
+            const itemConfig = getPayloadConfigFromPayload(config, item, key);
+            const indicatorColor = withCssVarFallback(
+              color ?? item.payload?.fill ?? item.color,
+              getDefaultChartColor(index),
+            );
+
+            return (
+              <div
+                key={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 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 != null && (
+                        <span className="font-mono font-medium tabular-nums text-foreground">
+                          {typeof item.value === 'number'
+                            ? item.value.toLocaleString()
+                            : String(item.value)}
+                        </span>
+                      )}
+                    </div>
+                  </>
+                )}
+              </div>
+            );
+          })}
+      </div>
+    </div>
+  );
+}
+
+/* -------------------------------------------------------------------------- */
+/*  ChartLegend + ChartLegendContent                                         */
+/* -------------------------------------------------------------------------- */
+
+export const ChartLegend = RechartsPrimitive.Legend;
+
+export function ChartLegendContent({
+  className,
+  hideIcon = false,
+  payload,
+  verticalAlign = 'bottom',
+  nameKey,
+}: ComponentProps<'div'> & {
+  hideIcon?: boolean;
+  nameKey?: string;
+} & RechartsPrimitive.DefaultLegendContentProps) {
+  const { config } = useChart();
+
+  if (!payload?.length) {
+    return null;
+  }
+
+  return (
+    <div
+      className={cn(
+        'flex items-center justify-center gap-4',
+        verticalAlign === 'top' ? 'pb-3' : 'pt-3',
+        className,
+      )}
+    >
+      {payload
+        .filter((item) => item.type !== 'none')
+        .map((item, index) => {
+          const key = `${nameKey ?? item.dataKey ?? 'value'}`;
+          const itemConfig = getPayloadConfigFromPayload(config, item, key);
+          const label = itemConfig?.label ?? getLegendItemLabel(item.value ?? item.dataKey);
+          const markerColor = withCssVarFallback(
+            item.color,
+            getDefaultChartColor(index),
+          );
+
+          return (
+            <div
+              key={index}
+              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: markerColor }}
+                />
+              )}
+              {label ? <span>{label}</span> : null}
+            </div>
+          );
+        })}
+    </div>
+  );
+}
+
+/* -------------------------------------------------------------------------- */
+/*  Helper                                                                    */
+/* -------------------------------------------------------------------------- */
+
+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];
+}
+
+function withCssVarFallback(
+  color: string | number | undefined,
+  fallbackColor: string,
+): string {
+  if (typeof color !== 'string' || color.trim() === '') {
+    return fallbackColor;
+  }
+
+  const trimmed = color.trim();
+  const cssVarMatch = /^var\((--[\w-]+)\)$/.exec(trimmed);
+
+  if (!cssVarMatch) {
+    return trimmed;
+  }
+
+  if (fallbackColor.startsWith(`var(${cssVarMatch[1]},`)) {
+    return fallbackColor;
+  }
+
+  return `var(${cssVarMatch[1]}, ${fallbackColor})`;
+}
+
+function getDefaultChartColor(index: number): string {
+  return (
+    DEFAULT_CHART_COLORS[index % DEFAULT_CHART_COLORS.length] ??
+    DEFAULT_CHART_COLORS[0]
+  );
+}
+
+function getLegendItemLabel(value: unknown): ReactNode {
+  if (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    typeof value === 'bigint'
+  ) {
+    return String(value);
+  }
+
+  return null;
+}

package/src/Checkbox.native.tsx

@@ -0,0 +1,69 @@
+/**
+ * Checkbox (React Native variant).
+ *
+ * Three-state checkbox using Pressable. `accessibilityRole="checkbox"`
+ * + `accessibilityState.checked` (boolean or "mixed").
+ *
+ * Wiki: docs/components/Checkbox.md
+ */
+import { forwardRef } from 'react';
+import { Pressable, Text, View, type PressableProps } from 'react-native';
+import { cva, type VariantProps } from 'class-variance-authority';
+import { cn } from './internal/cn.js';
+
+export type CheckedState = boolean | 'indeterminate';
+
+export const checkboxVariants = cva(
+  'items-center justify-center rounded border border-input bg-background',
+  {
+    variants: {
+      size: {
+        sm: 'h-4 w-4',
+        md: 'h-5 w-5',
+        lg: 'h-6 w-6',
+      },
+    },
+    defaultVariants: { size: 'md' },
+  },
+);
+
+export interface CheckboxProps
+  extends Omit<PressableProps, 'onPress' | 'children' | 'style'>,
+    VariantProps<typeof checkboxVariants> {
+  checked: CheckedState;
+  onCheckedChange: (checked: CheckedState) => void;
+  className?: string;
+}
+
+export const Checkbox = forwardRef<View, CheckboxProps>(function Checkbox(
+  { className, size = 'md', checked, onCheckedChange, disabled, ...props },
+  ref,
+) {
+  const sz = size ?? 'md';
+  const isChecked = checked === true;
+  const isMixed = checked === 'indeterminate';
+  const glyph = isChecked ? '✓' : isMixed ? '–' : '';
+  return (
+    <Pressable
+      ref={ref as never}
+      accessibilityRole="checkbox"
+      accessibilityState={{
+        checked: isMixed ? 'mixed' : isChecked,
+        disabled: !!disabled,
+      }}
+      disabled={disabled}
+      onPress={() => onCheckedChange(checked === true ? false : true)}
+      className={cn(
+        checkboxVariants({ size: sz }),
+        (isChecked || isMixed) && 'bg-primary border-primary',
+        disabled && 'opacity-50',
+        className,
+      )}
+      {...props}
+    >
+      {glyph ? (
+        <Text className="text-primary-foreground text-sm font-bold leading-none">{glyph}</Text>
+      ) : null}
+    </Pressable>
+  );
+});

package/src/Checkbox.tsx

@@ -0,0 +1,108 @@
+'use client';
+
+/**
+ * Checkbox (web variant — React DOM).
+ *
+ * Renders a `<button role="checkbox">` with `aria-checked` driven by
+ * `checked`. Supports three states: `true`, `false`, `"indeterminate"`
+ * — the latter renders a minus-glyph and announces as mixed via
+ * `aria-checked="mixed"`.
+ *
+ * Controlled-only by design. Pair with `Label` and link them via
+ * `id` / `htmlFor` so the label is a click target.
+ *
+ * Wiki: docs/components/Checkbox.md
+ */
+import { forwardRef, type ButtonHTMLAttributes } from 'react';
+import { cva, type VariantProps } from 'class-variance-authority';
+import { cn } from './internal/cn.js';
+
+export type CheckedState = boolean | 'indeterminate';
+
+export const checkboxVariants = cva(
+  'peer inline-flex shrink-0 items-center justify-center rounded ' +
+    'border-2 border-brand-neutral-179 bg-background ' +
+    'transition-colors duration-150 ' +
+    'focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 ' +
+    'disabled:cursor-not-allowed disabled:opacity-50',
+  {
+    variants: {
+      size: {
+        sm: 'h-3.5 w-3.5',
+        md: 'h-4 w-4',
+        lg: 'h-5 w-5',
+      },
+    },
+    defaultVariants: { size: 'md' },
+  },
+);
+
+const ICON_SIZE = { sm: 'h-2.5 w-2.5', md: 'h-3 w-3', lg: 'h-3.5 w-3.5' } as const;
+
+export type CheckboxTone = 'primary' | 'accent';
+
+const TONE_CLASSES: Record<CheckboxTone, string> = {
+  primary: 'bg-primary border-primary text-primary-foreground',
+  accent: 'bg-accent border-accent text-accent-foreground',
+};
+
+export interface CheckboxProps
+  extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'children' | 'type'>,
+    VariantProps<typeof checkboxVariants> {
+  checked: CheckedState;
+  onCheckedChange: (checked: CheckedState) => void;
+  /** Colour tone when checked. Defaults to `primary`. */
+  tone?: CheckboxTone;
+}
+
+export const Checkbox = forwardRef<HTMLButtonElement, CheckboxProps>(function Checkbox(
+  { className, size = 'md', checked, onCheckedChange, disabled, tone = 'primary', ...props },
+  ref,
+) {
+  const sz = size ?? 'md';
+  const isChecked = checked === true;
+  const isMixed = checked === 'indeterminate';
+  return (
+    <button
+      ref={ref}
+      type="button"
+      role="checkbox"
+      aria-checked={isMixed ? 'mixed' : isChecked}
+      disabled={disabled}
+      onClick={() => onCheckedChange(checked === true ? false : true)}
+      className={cn(
+        checkboxVariants({ size: sz }),
+        (isChecked || isMixed) && TONE_CLASSES[tone],
+        className,
+      )}
+      {...props}
+    >
+      {isChecked ? (
+        <svg
+          aria-hidden
+          viewBox="0 0 16 16"
+          fill="none"
+          stroke="currentColor"
+          strokeWidth={3}
+          strokeLinecap="round"
+          strokeLinejoin="round"
+          className={ICON_SIZE[sz]}
+        >
+          <path d="M3 8l3 3 7-7" />
+        </svg>
+      ) : isMixed ? (
+        <svg
+          aria-hidden
+          viewBox="0 0 16 16"
+          fill="none"
+          stroke="currentColor"
+          strokeWidth={3}
+          strokeLinecap="round"
+          className={ICON_SIZE[sz]}
+        >
+          <line x1="3" y1="8" x2="13" y2="8" />
+        </svg>
+      ) : null}
+    </button>
+  );
+});