@aaas-pro/library 0.0.0-stage → 0.1.0

package/dist/lib/variants.d.ts

@@ -0,0 +1,21 @@
+import { type ClassValue } from './class-names';
+type VariantMap = Record<string, Record<string, ClassValue>>;
+type Value<V> = V extends 'true' | 'false' ? boolean : V;
+type Selection<V extends VariantMap> = {
+    [K in keyof V]?: Value<keyof V[K]> | null | undefined;
+};
+type ClassProps = {
+    class?: ClassValue;
+    className?: ClassValue;
+};
+type Compound<V extends VariantMap> = {
+    [K in keyof V]?: Selection<V>[K] | Selection<V>[K][];
+} & ClassProps;
+export type VariantProps<T extends (...args: any[]) => unknown> = Omit<Exclude<Parameters<T>[0], undefined>, 'class' | 'className'>;
+/** Typed variants: undefined uses the default; null explicitly omits the variant. */
+export declare function cva<V extends VariantMap = Record<never, never>>(base?: ClassValue, config?: {
+    variants?: V;
+    defaultVariants?: Selection<V>;
+    compoundVariants?: Compound<V>[];
+}): (props?: Selection<V> & ClassProps) => string;
+export {};

package/dist/lib/variants.js

@@ -0,0 +1,21 @@
+import { classNames } from "./class-names.js";
+function cva(base, config) {
+  return (props) => {
+    const classes = [base];
+    const selected = { ...config?.defaultVariants };
+    for (const key of Object.keys(config?.variants ?? {})) {
+      const value = props?.[key] === void 0 ? config?.defaultVariants?.[key] : props[key];
+      selected[key] = value;
+      if (value !== null && value !== void 0) classes.push(config?.variants?.[key]?.[String(value)]);
+    }
+    for (const compound of config?.compoundVariants ?? []) {
+      const { class: extra, className, ...conditions } = compound;
+      if (Object.entries(conditions).every(([key, expected]) => Array.isArray(expected) ? expected.includes(selected[key]) : expected === selected[key])) classes.push(extra, className);
+    }
+    classes.push(props?.class, props?.className);
+    return classNames(...classes);
+  };
+}
+export {
+  cva
+};

package/dist/primitives/accordion.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { type ButtonProps, type DivProps } from './core';
+type Selection = {
+    type: 'single';
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+} | {
+    type: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+};
+export type AccordionProps = Omit<DivProps, 'defaultValue'> & Selection & {
+    collapsible?: boolean;
+    disabled?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+};
+export declare function Root({ type, value, defaultValue, onValueChange, collapsible, disabled, orientation, onKeyDown, ...props }: AccordionProps): React.JSX.Element;
+export declare function Item({ value, disabled, ...props }: DivProps & {
+    value: string;
+    disabled?: boolean;
+}): React.JSX.Element;
+export declare function Header(props: React.ComponentProps<'h3'>): React.JSX.Element;
+export declare function Trigger({ onClick, ...props }: ButtonProps): React.JSX.Element;
+export declare function Content({ forceMount, ...props }: DivProps & {
+    forceMount?: true;
+}): React.JSX.Element | null;
+export {};

package/dist/primitives/accordion.js

@@ -0,0 +1,49 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { DivPart, useControllable, moveFocus, ButtonPart } from "./core.js";
+const Context = React.createContext({ values: [], toggle: (_value) => {
+}, disabled: false });
+const ItemContext = React.createContext({ open: false, value: "", disabled: false, id: "" });
+function Root({ type, value, defaultValue, onValueChange, collapsible = false, disabled = false, orientation = "vertical", onKeyDown, ...props }) {
+  const [current, set] = useControllable(value, defaultValue ?? (type === "single" ? "" : []), (next) => {
+    if (type === "single")
+      onValueChange?.(next);
+    else
+      onValueChange?.(next);
+  });
+  const values = Array.isArray(current) ? current : current ? [current] : [];
+  const toggle = (key) => set(type === "single" ? values.includes(key) ? collapsible ? "" : key : key : values.includes(key) ? values.filter((v) => v !== key) : [...values, key]);
+  return /* @__PURE__ */ jsx(Context.Provider, { value: { values, toggle, disabled }, children: /* @__PURE__ */ jsx(DivPart, { ...props, "data-orientation": orientation, onKeyDown: (event) => {
+    onKeyDown?.(event);
+    if (!event.defaultPrevented)
+      moveFocus(event, "[data-accordion-trigger]", { vertical: orientation === "vertical" });
+  } }) });
+}
+function Item({ value, disabled = false, ...props }) {
+  const state = React.useContext(Context);
+  const id = React.useId();
+  const open = state.values.includes(value);
+  return /* @__PURE__ */ jsx(ItemContext.Provider, { value: { open, value, disabled: disabled || state.disabled, id }, children: /* @__PURE__ */ jsx(DivPart, { ...props, "data-state": open ? "open" : "closed", "data-disabled": disabled || state.disabled ? "" : void 0 }) });
+}
+function Header(props) {
+  return /* @__PURE__ */ jsx("h3", { ...props });
+}
+function Trigger({ onClick, ...props }) {
+  const state = React.useContext(Context), item = React.useContext(ItemContext);
+  return /* @__PURE__ */ jsx(ButtonPart, { ...props, id: `${item.id}-trigger`, "data-accordion-trigger": "", disabled: item.disabled || props.disabled, "aria-expanded": item.open, "aria-controls": `${item.id}-content`, "data-state": item.open ? "open" : "closed", onClick: (event) => {
+    onClick?.(event);
+    if (!event.defaultPrevented)
+      state.toggle(item.value);
+  } });
+}
+function Content({ forceMount, ...props }) {
+  const item = React.useContext(ItemContext);
+  return item.open || forceMount ? /* @__PURE__ */ jsx(DivPart, { ...props, id: `${item.id}-content`, role: "region", "aria-labelledby": `${item.id}-trigger`, hidden: !item.open, "data-state": item.open ? "open" : "closed" }) : null;
+}
+export {
+  Content,
+  Header,
+  Item,
+  Root,
+  Trigger
+};

package/dist/primitives/alert-dialog.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { type ModalRootProps, type ModalContentProps } from './layer';
+import type { ButtonProps } from './core';
+export declare const Trigger: ({ onClick, onKeyDown, onPointerEnter, onPointerLeave, onFocus, onBlur, onContextMenu, ref, disabled, ...props }: ButtonProps) => React.JSX.Element, Close: ({ onClick, ...props }: ButtonProps) => React.JSX.Element, Portal: ({ children, container, forceMount }: import("./layer").PortalProps) => React.ReactPortal | null, Overlay: ({ forceMount, ...props }: import("./core").DivProps & {
+    forceMount?: true;
+}) => React.JSX.Element | null, Title: (props: React.ComponentProps<"h2">) => React.JSX.Element, Description: (props: React.ComponentProps<"p">) => React.JSX.Element;
+export declare const Root: (props: ModalRootProps) => React.ReactElement;
+export declare const Content: (props: ModalContentProps) => React.ReactElement | null;
+export declare const Action: ({ onClick, ...props }: ButtonProps) => React.JSX.Element;
+export declare function Cancel(props: ButtonProps): React.JSX.Element;

package/dist/primitives/alert-dialog.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { createLayer } from "./layer.js";
+const family = createLayer({ modal: true, floating: false, role: "alertdialog", alert: true });
+const { Trigger, Close, Portal, Overlay, Title, Description } = family;
+const Root = family.Root;
+const Content = family.Content;
+const Action = Close;
+function Cancel(props) {
+  return /* @__PURE__ */ jsx(Close, { "data-slot": "alert-dialog-cancel", ...props });
+}
+export {
+  Action,
+  Cancel,
+  Close,
+  Content,
+  Description,
+  Overlay,
+  Portal,
+  Root,
+  Title,
+  Trigger
+};

package/dist/primitives/aspect-ratio.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export declare function Root({ ratio, style, ...props }: React.ComponentProps<'div'> & {
+    ratio?: number;
+}): React.JSX.Element;

package/dist/primitives/aspect-ratio.js

@@ -0,0 +1,7 @@
+import { jsx } from "react/jsx-runtime";
+function Root({ ratio = 1, style, ...props }) {
+  return /* @__PURE__ */ jsx("div", { ...props, style: { position: "relative", width: "100%", aspectRatio: Number.isFinite(ratio) && ratio > 0 ? ratio : 1, ...style } });
+}
+export {
+  Root
+};

package/dist/primitives/avatar.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export declare function Root(props: React.ComponentProps<'span'>): React.JSX.Element;
+export declare function Image({ onLoadingStatusChange, onLoad, onError, src, style, ...props }: React.ComponentProps<'img'> & {
+    onLoadingStatusChange?: (status: 'idle' | 'loading' | 'loaded' | 'error') => void;
+}): React.JSX.Element;
+export declare function Fallback({ delayMs, ...props }: React.ComponentProps<'span'> & {
+    delayMs?: number;
+}): React.JSX.Element | null;

package/dist/primitives/avatar.js

@@ -0,0 +1,45 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+const Context = React.createContext({ status: "idle", set: (_status) => {
+} });
+function Root(props) {
+  const [status, set] = React.useState("idle");
+  return /* @__PURE__ */ jsx(Context.Provider, { value: { status, set }, children: /* @__PURE__ */ jsx("span", { ...props }) });
+}
+function Image({ onLoadingStatusChange, onLoad, onError, src, style, ...props }) {
+  const context = React.useContext(Context), ref = React.useRef(null), merged = React.useMemo(() => (node) => {
+    ref.current = node;
+    if (typeof props.ref === "function")
+      props.ref(node);
+    else if (props.ref)
+      props.ref.current = node;
+  }, [props.ref]);
+  React.useEffect(() => {
+    const status = src ? ref.current?.complete && ref.current.naturalWidth ? "loaded" : "loading" : "error";
+    context.set(status);
+    onLoadingStatusChange?.(status);
+  }, [src]);
+  return /* @__PURE__ */ jsx("img", { ...props, ref: merged, src, style: { ...style, display: context.status === "loaded" ? style?.display : "none" }, onLoad: (event) => {
+    context.set("loaded");
+    onLoadingStatusChange?.("loaded");
+    onLoad?.(event);
+  }, onError: (event) => {
+    context.set("error");
+    onLoadingStatusChange?.("error");
+    onError?.(event);
+  } });
+}
+function Fallback({ delayMs = 0, ...props }) {
+  const { status } = React.useContext(Context);
+  const [ready, setReady] = React.useState(!delayMs);
+  React.useEffect(() => {
+    const timer = setTimeout(() => setReady(true), delayMs);
+    return () => clearTimeout(timer);
+  }, [delayMs]);
+  return ready && status !== "loaded" ? /* @__PURE__ */ jsx("span", { ...props }) : null;
+}
+export {
+  Fallback,
+  Image,
+  Root
+};

package/dist/primitives/carousel.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+export interface CarouselOptions {
+    axis?: 'x' | 'y';
+    loop?: boolean;
+    startIndex?: number;
+    slidesToScroll?: number;
+    align?: 'start' | 'center' | 'end';
+}
+type EventName = 'select' | 'reInit';
+export interface CarouselApi {
+    scrollPrev(): void;
+    scrollNext(): void;
+    scrollTo(index: number): void;
+    canScrollPrev(): boolean;
+    canScrollNext(): boolean;
+    selectedScrollSnap(): number;
+    scrollSnapList(): number[];
+    on(event: EventName, callback: (api: CarouselApi) => void): CarouselApi;
+    off(event: EventName, callback: (api: CarouselApi) => void): CarouselApi;
+}
+export default function useCarouselEngine(options?: CarouselOptions): readonly [React.Dispatch<React.SetStateAction<HTMLDivElement | null>>, CarouselApi];
+export {};

package/dist/primitives/carousel.js

@@ -0,0 +1,78 @@
+import * as React from "react";
+function useCarouselEngine(options = {}) {
+  const [node, setNode] = React.useState(null);
+  const latest = React.useRef({ index: options.startIndex ?? 0, count: 0, node, options });
+  latest.current.node = node;
+  latest.current.options = options;
+  const listeners = React.useRef({ select: /* @__PURE__ */ new Set(), reInit: /* @__PURE__ */ new Set() });
+  const api = React.useMemo(() => {
+    const change = (requested) => {
+      const state = latest.current, count = state.count;
+      if (!count) return;
+      const index = state.options.loop ? (requested % count + count) % count : Math.max(0, Math.min(count - 1, requested));
+      const slides = state.node?.querySelectorAll('[data-slot="carousel-item"]'), slide = slides?.[index];
+      if (state.node && slide) {
+        const bounds = state.node.getBoundingClientRect(), rect = slide.getBoundingClientRect();
+        const vertical = state.options.axis === "y";
+        const adjustment = state.options.align === "center" ? (vertical ? bounds.height - rect.height : bounds.width - rect.width) / 2 : state.options.align === "end" ? vertical ? bounds.height - rect.height : bounds.width - rect.width : 0;
+        const offset = (vertical ? rect.top - bounds.top + state.node.scrollTop : rect.left - bounds.left + state.node.scrollLeft) - adjustment;
+        state.node.scrollTo?.({ [vertical ? "top" : "left"]: offset, behavior: "smooth" });
+      }
+      state.index = index;
+      listeners.current.select.forEach((callback) => callback(api));
+    };
+    return { scrollTo: change, scrollPrev: () => change(latest.current.index - Math.max(1, latest.current.options.slidesToScroll ?? 1)), scrollNext: () => change(latest.current.index + Math.max(1, latest.current.options.slidesToScroll ?? 1)), canScrollPrev: () => latest.current.count > 1 && (!!latest.current.options.loop || latest.current.index > 0), canScrollNext: () => latest.current.count > 1 && (!!latest.current.options.loop || latest.current.index < latest.current.count - 1), selectedScrollSnap: () => latest.current.index, scrollSnapList: () => Array.from({ length: latest.current.count }, (_, i) => i), on: (event, callback) => {
+      listeners.current[event].add(callback);
+      return api;
+    }, off: (event, callback) => {
+      listeners.current[event].delete(callback);
+      return api;
+    } };
+  }, []);
+  React.useEffect(() => {
+    if (!node) return;
+    const update = () => {
+      latest.current.count = node.querySelectorAll('[data-slot="carousel-item"]').length;
+      latest.current.index = Math.min(latest.current.index, Math.max(0, latest.current.count - 1));
+      listeners.current.reInit.forEach((callback) => callback(api));
+    };
+    const scroll = () => {
+      const slides = [...node.querySelectorAll('[data-slot="carousel-item"]')], bounds = node.getBoundingClientRect();
+      const index = slides.reduce((best, slide, i) => Math.abs(options.axis === "y" ? slide.getBoundingClientRect().top - bounds.top : slide.getBoundingClientRect().left - bounds.left) < Math.abs(options.axis === "y" ? slides[best].getBoundingClientRect().top - bounds.top : slides[best].getBoundingClientRect().left - bounds.left) ? i : best, 0);
+      if (index !== latest.current.index) {
+        latest.current.index = index;
+        listeners.current.select.forEach((callback) => callback(api));
+      }
+    };
+    let start;
+    const down = (event) => {
+      if (event.button === 0) start = { x: event.clientX, y: event.clientY };
+    };
+    const up = (event) => {
+      if (!start) return;
+      const delta = options.axis === "y" ? event.clientY - start.y : event.clientX - start.x;
+      start = void 0;
+      if (Math.abs(delta) > 40) delta < 0 ? api.scrollNext() : api.scrollPrev();
+    };
+    update();
+    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(update);
+    observer?.observe(node);
+    const mutation = new MutationObserver(update);
+    mutation.observe(node, { childList: true, subtree: true });
+    node.addEventListener("scroll", scroll);
+    node.addEventListener("pointerdown", down);
+    window.addEventListener("pointerup", up);
+    api.scrollTo(options.startIndex ?? 0);
+    return () => {
+      observer?.disconnect();
+      mutation.disconnect();
+      node.removeEventListener("scroll", scroll);
+      node.removeEventListener("pointerdown", down);
+      window.removeEventListener("pointerup", up);
+    };
+  }, [node, api, options.axis, options.startIndex]);
+  return [setNode, api];
+}
+export {
+  useCarouselEngine as default
+};

package/dist/primitives/chart.d.ts

@@ -0,0 +1,71 @@
+import * as React from 'react';
+export interface ChartPayload {
+    dataKey: string;
+    name: string;
+    value: number;
+    color?: string;
+    type?: string;
+    payload: Record<string, any>;
+}
+export interface TooltipProps {
+    active?: boolean;
+    payload?: ChartPayload[];
+    label?: React.ReactNode;
+    content?: React.ReactElement | ((props: TooltipProps) => React.ReactNode);
+    formatter?: (value: number, name: string, item: ChartPayload, index: number, row: Record<string, any>) => React.ReactNode;
+    labelFormatter?: (label: React.ReactNode, payload: ChartPayload[]) => React.ReactNode;
+    color?: string;
+}
+export interface LegendProps {
+    payload?: ChartPayload[];
+    verticalAlign?: 'top' | 'bottom';
+    content?: React.ReactElement | ((props: LegendProps) => React.ReactNode);
+}
+export interface SeriesProps {
+    dataKey: string;
+    name?: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    radius?: number;
+    hide?: boolean;
+}
+export interface AxisProps {
+    dataKey?: string;
+    hide?: boolean;
+    tickFormatter?: (value: string | number) => string;
+}
+export interface ChartProps extends Omit<React.ComponentProps<'div'>, 'onChange'> {
+    data: Record<string, any>[];
+    width?: number;
+    height?: number;
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+}
+export declare function Bar(_props: SeriesProps): null;
+export declare function Line(_props: SeriesProps): null;
+export declare function Area(_props: SeriesProps): null;
+export declare function XAxis(_props: AxisProps): null;
+export declare function YAxis(_props: AxisProps): null;
+export declare function CartesianGrid(_props: {
+    stroke?: string;
+    strokeDasharray?: string;
+    vertical?: boolean;
+    horizontal?: boolean;
+}): null;
+export declare function ResponsiveContainer({ children, width, height }: {
+    children: React.ReactElement;
+    width?: number | string;
+    height?: number | string;
+}): React.JSX.Element;
+declare function CartesianChart({ data, children, width, height, margin, style, ...props }: ChartProps): React.JSX.Element;
+export declare const BarChart: typeof CartesianChart;
+export declare const LineChart: typeof CartesianChart;
+export declare const AreaChart: typeof CartesianChart;
+export declare function Tooltip(props: TooltipProps): React.JSX.Element | null;
+export declare function Legend(props: LegendProps): React.JSX.Element;
+export {};

package/dist/primitives/chart.js

@@ -0,0 +1,125 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+const Context = React.createContext({ active: false, payload: [], legend: [] });
+function Bar(_props) {
+  return null;
+}
+function Line(_props) {
+  return null;
+}
+function Area(_props) {
+  return null;
+}
+function XAxis(_props) {
+  return null;
+}
+function YAxis(_props) {
+  return null;
+}
+function CartesianGrid(_props) {
+  return null;
+}
+function chartChildren(children) {
+  return React.Children.toArray(children).flatMap((child) => React.isValidElement(child) ? child.type === React.Fragment ? chartChildren(child.props.children) : [child] : []);
+}
+function ResponsiveContainer({ children, width = "100%", height = "100%" }) {
+  const node = React.useRef(null), [size, setSize] = React.useState({ width: 640, height: 320 });
+  React.useEffect(() => {
+    const update = () => {
+      const bounds = node.current?.getBoundingClientRect();
+      if (bounds?.width && bounds.height) setSize({ width: bounds.width, height: bounds.height });
+    };
+    update();
+    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(update);
+    if (node.current) observer?.observe(node.current);
+    window.addEventListener("resize", update);
+    return () => {
+      observer?.disconnect();
+      window.removeEventListener("resize", update);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx("div", { ref: node, style: { width, height, minWidth: 0, minHeight: 0 }, children: React.cloneElement(children, size) });
+}
+function CartesianChart({ data, children, width = 640, height = 320, margin, style, ...props }) {
+  const [activeIndex, setActiveIndex] = React.useState(null);
+  const tooltipId = React.useId();
+  const elements = chartChildren(children), series = elements.filter((child) => [Bar, Line, Area].includes(child.type) && !child.props.hide);
+  const axisX = elements.find((child) => child.type === XAxis)?.props, axisY = elements.find((child) => child.type === YAxis)?.props;
+  const grid = elements.find((child) => child.type === CartesianGrid)?.props;
+  const legend = elements.find((child) => child.type === Legend)?.props;
+  const frame = { top: margin?.top ?? (legend?.verticalAlign === "top" ? 36 : 16), bottom: margin?.bottom ?? (legend && legend.verticalAlign !== "top" ? 48 : axisX && !axisX.hide ? 32 : 16), left: margin?.left ?? (axisY && !axisY.hide ? 44 : 16), right: margin?.right ?? 16 };
+  const plotWidth = Math.max(1, width - frame.left - frame.right), plotHeight = Math.max(1, height - frame.top - frame.bottom);
+  const values = data.flatMap((row) => series.map((child) => Number(row[child.props.dataKey]) || 0));
+  const low = Math.min(0, ...values), high = Math.max(0, ...values) || 1;
+  const y = (value) => frame.top + (high - value) / (high - low) * plotHeight, base = y(0), band = plotWidth / Math.max(1, data.length), x = (index) => frame.left + band * (index + 0.5);
+  const barSeries = series.filter((child) => child.type === Bar), barWidth = band * 0.7 / Math.max(1, barSeries.length);
+  const payload = (row) => series.map((child) => {
+    const item = child.props;
+    return { dataKey: item.dataKey, name: item.name ?? item.dataKey, value: Number(row[item.dataKey]) || 0, color: item.fill ?? item.stroke ?? `var(--color-${item.dataKey}, var(--primary))`, payload: row };
+  });
+  const active = activeIndex !== null && !!data[activeIndex];
+  const label = active ? String(axisX?.dataKey ? data[activeIndex][axisX.dataKey] ?? "" : data[activeIndex].name ?? activeIndex + 1) : void 0;
+  return /* @__PURE__ */ jsx(Context.Provider, { value: { active, payload: active ? payload(data[activeIndex]) : [], legend: payload(data[0] ?? {}), label, tooltipId }, children: /* @__PURE__ */ jsxs("div", { ...props, "data-slot": "cartesian-chart", style: { position: "relative", width, height, ...style }, onMouseLeave: () => setActiveIndex(null), children: [
+    /* @__PURE__ */ jsxs("svg", { role: "img", "aria-label": props["aria-label"] ?? "数据图表", width: "100%", height: "100%", viewBox: `0 0 ${width} ${height}`, children: [
+      grid && grid.horizontal !== false && Array.from({ length: 5 }, (_, index) => /* @__PURE__ */ jsx("line", { x1: frame.left, x2: width - frame.right, y1: frame.top + plotHeight * index / 4, y2: frame.top + plotHeight * index / 4, stroke: grid.stroke ?? "var(--border)", strokeDasharray: grid.strokeDasharray, opacity: 0.7 }, index)),
+      grid?.vertical && data.map((_, index) => /* @__PURE__ */ jsx("line", { x1: x(index), x2: x(index), y1: frame.top, y2: height - frame.bottom, stroke: grid.stroke ?? "var(--border)", strokeDasharray: grid.strokeDasharray }, index)),
+      axisY && !axisY.hide && Array.from({ length: 5 }, (_, index) => {
+        const value = low + (high - low) * index / 4;
+        return /* @__PURE__ */ jsx("text", { x: frame.left - 8, y: y(value) + 4, textAnchor: "end", fill: "var(--muted-foreground)", fontSize: 11, children: axisY.tickFormatter ? axisY.tickFormatter(value) : Number(value.toFixed(2)) }, index);
+      }),
+      axisX && !axisX.hide && data.map((row, index) => /* @__PURE__ */ jsx("text", { x: x(index), y: height - frame.bottom + 20, textAnchor: "middle", fill: "var(--muted-foreground)", fontSize: 11, children: axisX.tickFormatter ? axisX.tickFormatter(row[axisX.dataKey ?? "name"] ?? index + 1) : String(row[axisX.dataKey ?? "name"] ?? index + 1) }, index)),
+      series.map((child, seriesIndex) => {
+        const item = child.props, color = item.fill ?? item.stroke ?? `var(--color-${item.dataKey}, var(--primary))`, points = data.map((row, index) => `${x(index)},${y(Number(row[item.dataKey]) || 0)}`).join(" ");
+        if (child.type === Bar) return /* @__PURE__ */ jsx("g", { "data-series": item.dataKey, children: data.map((row, index) => {
+          const value = Number(row[item.dataKey]) || 0, top = y(value);
+          return /* @__PURE__ */ jsx("rect", { "data-value": value, x: x(index) - band * 0.35 + barSeries.indexOf(child) * barWidth, y: Math.min(base, top), width: Math.max(1, barWidth - 2), height: Math.abs(base - top), rx: Math.max(0, item.radius ?? 3), fill: color }, index);
+        }) }, seriesIndex);
+        return /* @__PURE__ */ jsxs("g", { "data-series": item.dataKey, children: [
+          child.type === Area && data.length > 0 && /* @__PURE__ */ jsx("polygon", { points: `${x(0)},${base} ${points} ${x(data.length - 1)},${base}`, fill: color, opacity: 0.18 }),
+          /* @__PURE__ */ jsx("polyline", { points, fill: "none", stroke: item.stroke ?? color, strokeWidth: item.strokeWidth ?? 2 }),
+          data.map((row, index) => /* @__PURE__ */ jsx("circle", { cx: x(index), cy: y(Number(row[item.dataKey]) || 0), r: 3, fill: color }, index))
+        ] }, seriesIndex);
+      }),
+      data.map((row, index) => /* @__PURE__ */ jsx("rect", { "data-chart-index": index, "aria-describedby": activeIndex === index && elements.some((child) => child.type === Tooltip) ? tooltipId : void 0, role: "button", tabIndex: 0, "aria-label": payload(row).map((item) => `${item.name}：${item.value}`).join("，"), x: frame.left + band * index, y: frame.top, width: band, height: plotHeight, fill: "transparent", stroke: activeIndex === index ? "var(--primary)" : "transparent", strokeDasharray: "3 3", onMouseEnter: () => setActiveIndex(index), onFocus: () => setActiveIndex(index), onBlur: () => setActiveIndex(null), onKeyDown: (event) => {
+        if (["ArrowLeft", "ArrowRight", "Home", "End"].includes(event.key)) {
+          event.preventDefault();
+          const next = event.key === "Home" ? 0 : event.key === "End" ? data.length - 1 : Math.max(0, Math.min(data.length - 1, index + (event.key === "ArrowRight" ? 1 : -1)));
+          event.currentTarget.parentElement?.querySelector(`[data-chart-index="${next}"]`)?.focus();
+        }
+      } }, index))
+    ] }),
+    elements.filter((child) => child.type === Tooltip || child.type === Legend)
+  ] }) });
+}
+const BarChart = CartesianChart;
+const LineChart = CartesianChart;
+const AreaChart = CartesianChart;
+function Tooltip(props) {
+  const state = React.useContext(Context), actual = { ...props, active: props.active ?? state.active, payload: props.payload ?? state.payload, label: props.label ?? state.label };
+  if (!actual.active) return null;
+  return /* @__PURE__ */ jsx("div", { id: state.tooltipId, role: "tooltip", style: { position: "absolute", top: 8, right: 8, pointerEvents: "none" }, children: props.content ? typeof props.content === "function" ? props.content(actual) : React.cloneElement(props.content, actual) : /* @__PURE__ */ jsxs("div", { style: { background: "var(--popover)", color: "var(--popover-foreground)", padding: 12, border: "1px solid var(--border)", borderRadius: 8 }, children: [
+    /* @__PURE__ */ jsx("strong", { children: actual.label }),
+    actual.payload?.map((item, index) => /* @__PURE__ */ jsx("div", { children: props.formatter ? props.formatter(item.value, item.name, item, index, item.payload) : `${item.name}：${item.value}` }, item.dataKey))
+  ] }) });
+}
+function Legend(props) {
+  const state = React.useContext(Context), actual = { ...props, payload: props.payload ?? state.legend };
+  return /* @__PURE__ */ jsx("div", { style: { position: "absolute", [props.verticalAlign === "top" ? "top" : "bottom"]: 0, left: 0, right: 0 }, children: props.content ? typeof props.content === "function" ? props.content(actual) : React.cloneElement(props.content, actual) : /* @__PURE__ */ jsx("div", { style: { display: "flex", justifyContent: "center", gap: 16 }, children: actual.payload.map((item) => /* @__PURE__ */ jsxs("span", { style: { color: item.color }, children: [
+    "● ",
+    item.name
+  ] }, item.dataKey)) }) });
+}
+export {
+  Area,
+  AreaChart,
+  Bar,
+  BarChart,
+  CartesianGrid,
+  Legend,
+  Line,
+  LineChart,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis
+};

package/dist/primitives/checkbox.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { type ButtonProps } from './core';
+export type CheckedState = boolean | 'indeterminate';
+export interface CheckboxProps extends Omit<ButtonProps, 'defaultChecked' | 'onChange'> {
+    checked?: CheckedState;
+    defaultChecked?: CheckedState;
+    onCheckedChange?: (checked: CheckedState) => void;
+    required?: boolean;
+}
+export declare function Root({ checked, defaultChecked, onCheckedChange, onClick, children, name, value, required, ...props }: CheckboxProps): React.JSX.Element;
+export declare function Indicator({ forceMount, ...props }: React.ComponentProps<'span'> & {
+    forceMount?: true;
+}): React.JSX.Element | null;

package/dist/primitives/checkbox.js

@@ -0,0 +1,24 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { useControllable, ButtonPart } from "./core.js";
+const CheckedContext = React.createContext(false);
+function Root({ checked, defaultChecked = false, onCheckedChange, onClick, children, name, value = "on", required, ...props }) {
+  const [current, set] = useControllable(checked, defaultChecked, onCheckedChange);
+  return /* @__PURE__ */ jsxs(CheckedContext.Provider, { value: current, children: [
+    /* @__PURE__ */ jsx(ButtonPart, { ...props, role: "checkbox", "aria-checked": current === "indeterminate" ? "mixed" : current, "aria-required": required, "data-state": current === "indeterminate" ? "indeterminate" : current ? "checked" : "unchecked", "data-disabled": props.disabled ? "" : void 0, onClick: (event) => {
+      onClick?.(event);
+      if (!event.defaultPrevented)
+        set(current !== true);
+    }, children }),
+    name && /* @__PURE__ */ jsx("input", { type: "checkbox", tabIndex: -1, "aria-hidden": "true", name, value, required, disabled: props.disabled, checked: current === true, onChange: () => {
+    }, style: { position: "absolute", opacity: 0, width: 1, height: 1, pointerEvents: "none" } })
+  ] });
+}
+function Indicator({ forceMount, ...props }) {
+  const checked = React.useContext(CheckedContext);
+  return checked || forceMount ? /* @__PURE__ */ jsx("span", { ...props, hidden: !checked, "data-state": checked === "indeterminate" ? "indeterminate" : "checked" }) : null;
+}
+export {
+  Indicator,
+  Root
+};

package/dist/primitives/collapsible.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { type ButtonProps, type DivProps } from './core';
+export interface CollapsibleProps extends DivProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+}
+export declare function Root({ open, defaultOpen, onOpenChange, disabled, ...props }: CollapsibleProps): React.JSX.Element;
+export declare function Trigger({ onClick, ...props }: ButtonProps): React.JSX.Element;
+export declare function Content({ forceMount, ...props }: DivProps & {
+    forceMount?: true;
+}): React.JSX.Element | null;
+export { Trigger as CollapsibleTrigger, Content as CollapsibleContent };

package/dist/primitives/collapsible.js

@@ -0,0 +1,29 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { DivPart, ButtonPart, useControllable } from "./core.js";
+const Context = React.createContext({ open: false, setOpen: (_open) => {
+}, disabled: false, id: "" });
+function Root({ open, defaultOpen = false, onOpenChange, disabled = false, ...props }) {
+  const [current, setOpen] = useControllable(open, defaultOpen, onOpenChange);
+  const id = React.useId();
+  return /* @__PURE__ */ jsx(Context.Provider, { value: { open: current, setOpen, disabled, id }, children: /* @__PURE__ */ jsx(DivPart, { ...props, "data-state": current ? "open" : "closed", "data-disabled": disabled ? "" : void 0 }) });
+}
+function Trigger({ onClick, ...props }) {
+  const state = React.useContext(Context);
+  return /* @__PURE__ */ jsx(ButtonPart, { ...props, disabled: state.disabled || props.disabled, "aria-expanded": state.open, "aria-controls": state.id, "data-state": state.open ? "open" : "closed", onClick: (event) => {
+    onClick?.(event);
+    if (!event.defaultPrevented)
+      state.setOpen(!state.open);
+  } });
+}
+function Content({ forceMount, ...props }) {
+  const state = React.useContext(Context);
+  return state.open || forceMount ? /* @__PURE__ */ jsx(DivPart, { ...props, id: state.id, hidden: !state.open, "data-state": state.open ? "open" : "closed" }) : null;
+}
+export {
+  Content as CollapsibleContent,
+  Trigger as CollapsibleTrigger,
+  Content,
+  Root,
+  Trigger
+};