@turingpaper/ui 0.0.1-test.1 → 0.0.1-test.3

package/dist/chart.mjs

@@ -0,0 +1,208 @@
+import { jsx as s, jsxs as g, Fragment as T } from "react/jsx-runtime";
+import * as f from "react";
+import * as w from "recharts";
+import { cn as i } from "./utils.mjs";
+const P = { light: "", dark: ".dark" }, N = f.createContext(null);
+function j() {
+  const a = f.useContext(N);
+  if (!a)
+    throw new Error("useChart must be used within a <ChartContainer />");
+  return a;
+}
+const I = f.forwardRef(({ id: a, className: e, children: n, config: r, ...c }, d) => {
+  const l = f.useId(), o = `chart-${a || l.replace(/:/g, "")}`;
+  return /* @__PURE__ */ s(N.Provider, { value: { config: r }, children: /* @__PURE__ */ g(
+    "div",
+    {
+      "data-chart": o,
+      ref: d,
+      className: i(
+        "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-none [&_.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[stroke='#fff']]:stroke-transparent [&_.recharts-sector]:outline-none [&_.recharts-surface]:outline-none",
+        e
+      ),
+      ...c,
+      children: [
+        /* @__PURE__ */ s(S, { id: o, config: r }),
+        /* @__PURE__ */ s(w.ResponsiveContainer, { children: n })
+      ]
+    }
+  ) });
+});
+I.displayName = "Chart";
+const S = ({ id: a, config: e }) => {
+  const n = Object.entries(e).filter(
+    ([, r]) => r.theme || r.color
+  );
+  return n.length ? /* @__PURE__ */ s(
+    "style",
+    {
+      dangerouslySetInnerHTML: {
+        __html: Object.entries(P).map(
+          ([r, c]) => `
+${c} [data-chart=${a}] {
+${n.map(([d, l]) => {
+            const o = l.theme?.[r] || l.color;
+            return o ? `  --color-${d}: ${o};` : null;
+          }).join(`
+`)}
+}
+`
+        ).join(`
+`)
+      }
+    }
+  ) : null;
+}, O = w.Tooltip, E = f.forwardRef(
+  ({
+    active: a,
+    payload: e,
+    className: n,
+    indicator: r = "dot",
+    hideLabel: c = !1,
+    hideIndicator: d = !1,
+    label: l,
+    labelFormatter: o,
+    labelClassName: m,
+    formatter: h,
+    color: $,
+    nameKey: L,
+    labelKey: x
+  }, R) => {
+    const { config: p } = j(), k = f.useMemo(() => {
+      if (c || !e?.length)
+        return null;
+      const [t] = e, b = `${x || t?.dataKey || t?.name || "value"}`, C = _(p, t, b), u = !x && typeof l == "string" ? p[l]?.label || l : C?.label;
+      return o ? /* @__PURE__ */ s("div", { className: i("font-medium", m), children: o(u, e) }) : u ? /* @__PURE__ */ s("div", { className: i("font-medium", m), children: u }) : null;
+    }, [
+      l,
+      o,
+      e,
+      c,
+      m,
+      p,
+      x
+    ]);
+    if (!a || !e?.length)
+      return null;
+    const v = e.length === 1 && r !== "dot";
+    return /* @__PURE__ */ g(
+      "div",
+      {
+        ref: R,
+        className: i(
+          "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",
+          n
+        ),
+        children: [
+          v ? null : k,
+          /* @__PURE__ */ s("div", { className: "grid gap-1.5", children: e.filter((t) => t.type !== "none").map((t, b) => {
+            const C = `${L || t.name || t.dataKey || "value"}`, u = _(p, t, C), y = $ || t.payload.fill || t.color;
+            return /* @__PURE__ */ s(
+              "div",
+              {
+                className: i(
+                  "flex w-full flex-wrap items-stretch gap-2 [&>svg]:h-2.5 [&>svg]:w-2.5 [&>svg]:text-muted-foreground",
+                  r === "dot" && "items-center"
+                ),
+                children: h && t?.value !== void 0 && t.name ? h(t.value, t.name, t, b, t.payload) : /* @__PURE__ */ g(T, { children: [
+                  u?.icon ? /* @__PURE__ */ s(u.icon, {}) : !d && /* @__PURE__ */ s(
+                    "div",
+                    {
+                      className: i(
+                        "shrink-0 rounded-[2px] border-[--color-border] bg-[--color-bg]",
+                        {
+                          "h-2.5 w-2.5": r === "dot",
+                          "w-1": r === "line",
+                          "w-0 border-[1.5px] border-dashed bg-transparent": r === "dashed",
+                          "my-0.5": v && r === "dashed"
+                        }
+                      ),
+                      style: {
+                        "--color-bg": y,
+                        "--color-border": y
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ g(
+                    "div",
+                    {
+                      className: i(
+                        "flex flex-1 justify-between leading-none",
+                        v ? "items-end" : "items-center"
+                      ),
+                      children: [
+                        /* @__PURE__ */ g("div", { className: "grid gap-1.5", children: [
+                          v ? k : null,
+                          /* @__PURE__ */ s("span", { className: "text-muted-foreground", children: u?.label || t.name })
+                        ] }),
+                        t.value && /* @__PURE__ */ s("span", { className: "font-mono font-medium tabular-nums text-foreground", children: t.value.toLocaleString() })
+                      ]
+                    }
+                  )
+                ] })
+              },
+              t.dataKey
+            );
+          }) })
+        ]
+      }
+    );
+  }
+);
+E.displayName = "ChartTooltip";
+const q = w.Legend, K = f.forwardRef(
+  ({ className: a, hideIcon: e = !1, payload: n, verticalAlign: r = "bottom", nameKey: c }, d) => {
+    const { config: l } = j();
+    return n?.length ? /* @__PURE__ */ s(
+      "div",
+      {
+        ref: d,
+        className: i(
+          "flex items-center justify-center gap-4",
+          r === "top" ? "pb-3" : "pt-3",
+          a
+        ),
+        children: n.filter((o) => o.type !== "none").map((o) => {
+          const m = `${c || o.dataKey || "value"}`, h = _(l, o, m);
+          return /* @__PURE__ */ g(
+            "div",
+            {
+              className: i(
+                "flex items-center gap-1.5 [&>svg]:h-3 [&>svg]:w-3 [&>svg]:text-muted-foreground"
+              ),
+              children: [
+                h?.icon && !e ? /* @__PURE__ */ s(h.icon, {}) : /* @__PURE__ */ s(
+                  "div",
+                  {
+                    className: "h-2 w-2 shrink-0 rounded-[2px]",
+                    style: {
+                      backgroundColor: o.color
+                    }
+                  }
+                ),
+                h?.label
+              ]
+            },
+            o.value
+          );
+        })
+      }
+    ) : null;
+  }
+);
+K.displayName = "ChartLegend";
+function _(a, e, n) {
+  if (typeof e != "object" || e === null)
+    return;
+  const r = "payload" in e && typeof e.payload == "object" && e.payload !== null ? e.payload : void 0;
+  let c = n;
+  return n in e && typeof e[n] == "string" ? c = e[n] : r && n in r && typeof r[n] == "string" && (c = r[n]), c in a ? a[c] : a[n];
+}
+export {
+  I as ChartContainer,
+  q as ChartLegend,
+  K as ChartLegendContent,
+  S as ChartStyle,
+  O as ChartTooltip,
+  E as ChartTooltipContent
+};

package/dist/checkbox.mjs

@@ -0,0 +1,27 @@
+import { jsx as e } from "react/jsx-runtime";
+import * as c from "react";
+import * as r from "radix-ui";
+import { Check as s } from "lucide-react";
+import { cn as o } from "./utils.mjs";
+const n = c.forwardRef(({ className: i, ...t }, a) => /* @__PURE__ */ e(
+  r.Root,
+  {
+    ref: a,
+    className: o(
+      "grid place-content-center peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
+      i
+    ),
+    ...t,
+    children: /* @__PURE__ */ e(
+      r.Indicator,
+      {
+        className: o("grid place-content-center text-current"),
+        children: /* @__PURE__ */ e(s, { className: "h-4 w-4" })
+      }
+    )
+  }
+));
+n.displayName = r.Root.displayName;
+export {
+  n as Checkbox
+};

package/dist/collapsible.mjs

@@ -0,0 +1,7 @@
+import * as o from "radix-ui";
+const l = o.Root, e = o.CollapsibleTrigger, i = o.CollapsibleContent;
+export {
+  l as Collapsible,
+  i as CollapsibleContent,
+  e as CollapsibleTrigger
+};

package/dist/command.mjs

@@ -0,0 +1,109 @@
+import { jsx as t, jsxs as s } from "react/jsx-runtime";
+import * as m from "react";
+import { Command as o } from "cmdk";
+import { Search as p } from "lucide-react";
+import { cn as r } from "./utils.mjs";
+import { Dialog as i, DialogContent as l } from "./dialog.mjs";
+const n = m.forwardRef(({ className: e, ...a }, d) => /* @__PURE__ */ t(
+  o,
+  {
+    ref: d,
+    className: r(
+      "flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground",
+      e
+    ),
+    ...a
+  }
+));
+n.displayName = o.displayName;
+const C = ({ children: e, ...a }) => /* @__PURE__ */ t(i, { ...a, children: /* @__PURE__ */ t(l, { className: "overflow-hidden p-0 shadow-lg", children: /* @__PURE__ */ t(n, { className: "[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-group]]:px-2 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5", children: e }) }) }), c = m.forwardRef(({ className: e, ...a }, d) => /* @__PURE__ */ s("div", { className: "flex items-center border-b px-3", "cmdk-input-wrapper": "", children: [
+  /* @__PURE__ */ t(p, { className: "mr-2 h-4 w-4 shrink-0 opacity-50" }),
+  /* @__PURE__ */ t(
+    o.Input,
+    {
+      ref: d,
+      className: r(
+        "flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50",
+        e
+      ),
+      ...a
+    }
+  )
+] }));
+c.displayName = o.Input.displayName;
+const u = m.forwardRef(({ className: e, ...a }, d) => /* @__PURE__ */ t(
+  o.List,
+  {
+    ref: d,
+    className: r("max-h-[300px] overflow-y-auto overflow-x-hidden", e),
+    ...a
+  }
+));
+u.displayName = o.List.displayName;
+const f = m.forwardRef((e, a) => /* @__PURE__ */ t(
+  o.Empty,
+  {
+    ref: a,
+    className: "py-6 text-center text-sm",
+    ...e
+  }
+));
+f.displayName = o.Empty.displayName;
+const g = m.forwardRef(({ className: e, ...a }, d) => /* @__PURE__ */ t(
+  o.Group,
+  {
+    ref: d,
+    className: r(
+      "overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground",
+      e
+    ),
+    ...a
+  }
+));
+g.displayName = o.Group.displayName;
+const x = m.forwardRef(({ className: e, ...a }, d) => /* @__PURE__ */ t(
+  o.Separator,
+  {
+    ref: d,
+    className: r("-mx-1 h-px bg-border", e),
+    ...a
+  }
+));
+x.displayName = o.Separator.displayName;
+const h = m.forwardRef(({ className: e, ...a }, d) => /* @__PURE__ */ t(
+  o.Item,
+  {
+    ref: d,
+    className: r(
+      "relative flex cursor-default gap-2 select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none data-[disabled=true]:pointer-events-none data-[selected='true']:bg-accent data-[selected=true]:text-accent-foreground data-[disabled=true]:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
+      e
+    ),
+    ...a
+  }
+));
+h.displayName = o.Item.displayName;
+const y = ({
+  className: e,
+  ...a
+}) => /* @__PURE__ */ t(
+  "span",
+  {
+    className: r(
+      "ml-auto text-xs tracking-widest text-muted-foreground",
+      e
+    ),
+    ...a
+  }
+);
+y.displayName = "CommandShortcut";
+export {
+  n as Command,
+  C as CommandDialog,
+  f as CommandEmpty,
+  g as CommandGroup,
+  c as CommandInput,
+  h as CommandItem,
+  u as CommandList,
+  x as CommandSeparator,
+  y as CommandShortcut
+};

package/dist/components/accordion.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+declare const Accordion: any;
+declare const AccordionItem: React.ForwardRefExoticComponent<any>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<any>;
+declare const AccordionContent: React.ForwardRefExoticComponent<any>;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

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

@@ -0,0 +1,20 @@
+import * as React from "react";
+import * as AlertDialogPrimitive from "radix-ui";
+declare const AlertDialog: any;
+declare const AlertDialogTrigger: any;
+declare const AlertDialogPortal: typeof AlertDialogPrimitive.Portal;
+declare const AlertDialogOverlay: React.ForwardRefExoticComponent<any>;
+declare const AlertDialogContent: React.ForwardRefExoticComponent<any>;
+declare const AlertDialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const AlertDialogTitle: React.ForwardRefExoticComponent<any>;
+declare const AlertDialogDescription: React.ForwardRefExoticComponent<any>;
+declare const AlertDialogAction: React.ForwardRefExoticComponent<any>;
+declare const AlertDialogCancel: React.ForwardRefExoticComponent<any>;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/components/avatar.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const Avatar: React.ForwardRefExoticComponent<any>;
+declare const AvatarImage: React.ForwardRefExoticComponent<any>;
+declare const AvatarFallback: React.ForwardRefExoticComponent<any>;
+export { Avatar, AvatarImage, AvatarFallback };

package/dist/components/badge.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/components/breadcrumb.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+declare const Breadcrumb: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/components/button.d.ts

@@ -1,10 +1,11 @@
 import { VariantProps } from 'class-variance-authority';
 import * as React from "react";
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "outline" | "secondary" | "ghost" | "destructive" | null | undefined;
-    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
 export { Button, buttonVariants };

package/dist/components/card.d.ts

@@ -1,11 +1,8 @@
 import * as React from "react";
-declare function Card({ className, size, ...props }: React.ComponentProps<"div"> & {
-    size?: "default" | "sm";
-}): import("react/jsx-runtime").JSX.Element;
-declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function CardAction({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function CardContent({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent };

package/dist/components/chart.d.ts

@@ -0,0 +1,62 @@
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+export type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        icon?: React.ComponentType;
+    } & ({
+        color?: string;
+        theme?: never;
+    } | {
+        color?: never;
+        theme: Record<keyof typeof THEMES, string>;
+    });
+};
+declare const ChartContainer: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    config: ChartConfig;
+    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => import("react/jsx-runtime").JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare const ChartTooltipContent: React.ForwardRefExoticComponent<Omit<RechartsPrimitive.DefaultTooltipContentProps<import('recharts/types/component/DefaultTooltipContent').ValueType, import('recharts/types/component/DefaultTooltipContent').NameType> & {
+    accessibilityLayer?: boolean;
+    active?: boolean | undefined;
+    includeHidden?: boolean | undefined;
+    allowEscapeViewBox?: import('recharts/types/util/types').AllowInDimension;
+    animationDuration?: import('recharts/types/util/types').AnimationDuration;
+    animationEasing?: import('recharts/types/util/types').AnimationTiming;
+    content?: import('recharts/types/component/Tooltip').ContentType<import('recharts/types/component/DefaultTooltipContent').ValueType, import('recharts/types/component/DefaultTooltipContent').NameType> | undefined;
+    coordinate?: Partial<import('recharts/types/util/types').Coordinate>;
+    cursor?: boolean | React.ReactElement | React.SVGProps<SVGElement>;
+    filterNull?: boolean;
+    defaultIndex?: number;
+    isAnimationActive?: boolean;
+    offset?: number;
+    payloadUniqBy?: import('recharts/types/util/payload/getUniqPayload').UniqueOption<import('recharts/types/component/DefaultTooltipContent').Payload<import('recharts/types/component/DefaultTooltipContent').ValueType, import('recharts/types/component/DefaultTooltipContent').NameType>> | undefined;
+    position?: Partial<import('recharts/types/util/types').Coordinate>;
+    reverseDirection?: import('recharts/types/util/types').AllowInDimension;
+    shared?: boolean;
+    trigger?: "hover" | "click";
+    useTranslate3d?: boolean;
+    viewBox?: import('recharts/types/util/types').CartesianViewBox;
+    wrapperStyle?: React.CSSProperties;
+} & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChartLegend: typeof RechartsPrimitive.Legend;
+declare const ChartLegendContent: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & Pick<RechartsPrimitive.LegendProps, "payload" | "verticalAlign"> & {
+    hideIcon?: boolean;
+    nameKey?: string;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, };

package/dist/components/checkbox.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Checkbox: React.ForwardRefExoticComponent<any>;
+export { Checkbox };

package/dist/components/collapsible.d.ts

@@ -0,0 +1,4 @@
+declare const Collapsible: any;
+declare const CollapsibleTrigger: any;
+declare const CollapsibleContent: any;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/command.d.ts

@@ -0,0 +1,80 @@
+import { DialogProps } from 'radix-ui';
+import * as React from "react";
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandDialog: ({ children, ...props }: DialogProps) => import("react/jsx-runtime").JSX.Element;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key">, "value" | "heading"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | "key"> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | keyof React.HTMLAttributes<HTMLDivElement> | "key">, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import * as DialogPrimitive from "radix-ui";
+declare const Dialog: any;
+declare const DialogTrigger: any;
+declare const DialogPortal: typeof DialogPrimitive.Portal;
+declare const DialogClose: any;
+declare const DialogOverlay: React.ForwardRefExoticComponent<any>;
+declare const DialogContent: React.ForwardRefExoticComponent<any>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<any>;
+declare const DialogDescription: React.ForwardRefExoticComponent<any>;
+export { Dialog, DialogPortal, DialogOverlay, DialogClose, DialogTrigger, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };